JetAPI — Integração perfeita de API para WhatsApp, Telegram e outros mensageiros populares

Integração perfeita da API

Potencie as suas conversas online

Eleve o seu negócio integrando mensageiros populares como o WhatsApp, Telegram, Facebook e Instagram com o seu CRM, sistema de reservas ou qualquer outro serviço.

Experimentar a JetAPI

Saiba mais

Completo e sem falhas

Liberte o potencial da comunicação fluida com as diversas integrações e recursos da JetAPI, elevando sua experiência de mensagens de forma fácil.

Automatize a sua comunicação através do WhatsApp, garantindo uma interação atempada e eficiente.

Eleve sua conectividade com mensagens automatizadas através do Telegram.

Bots de conversação

Crie fluxos complexos e automatize conversas, promovendo um diálogo sem falhas com os seus clientes.

Cascata

Enviar mensagens utilizando o canal mais adequado para cada cliente.

API

Experiência de integração direta e simples da API.

Mensagens de marketing

Despache mensagens em massa sem esforço, execute campanhas de marketing com facilidade.

Necessidades dos criadores, totalmente cobertas!

Com o JetAPI, desfrute de suporte abrangente para diversas linguagens e estruturas, garantindo uma experiência de desenvolvimento sem emendas adaptada às suas necessidades.

request


var request = require("request");

var options = {
  method: "POST",
  url: "https://api.jetapi.io/api/v1/delivery",
  headers: { authorization: "Bearer yourtoken123456", "content-type": "application/json" },
  body: { text: "hello world", phone: "15551234567" },
  json: true,
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

node-fetch


import fetch from 'node-fetch';

const url = 'https://api.jetapi.io/api/v1/delivery';
const body = { text: 'hello world', phone: '15551234567' };
const headers = {
  authorization: 'Bearer yourtoken123456',
  'content-type': 'application/json',
};

const response = await fetch(url, {
  method: 'post',
  body: JSON.stringify(body),
  headers: headers,
});
const data = await response.json();

console.log(data);

http.client


import http.client

conn = http.client.HTTPSConnection("api.jetapi.io")

payload = "{\"text\":\"hello world\",\"phone\":\"15551234567\"}"
headers = { 'authorization': "Bearer yourtoken123456",
            'content-type': 'application/json'
}
conn.request("POST", "/api/v1/delivery", payload, headers)

res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))

Requests


import requests

url = "https://api.jetapi.io/api/v1/delivery"

payload = "{\"text\":\"hello world\",\"phone\":\"15551234567\"}"
headers = {
  'authorization': 'Bearer yourtoken123456',
  'content-type': 'application/json'
}

response = requests.request("POST", url, data = payload, headers = headers)
print(response.text)

Unirest


import kong.unirest.HttpResponse;
import kong.unirest.JsonNode;
import kong.unirest.Unirest;

// .....

HttpResponse<JsonNode> response = Unirest.post("https://api.jetapi.io/api/v1/delivery")
  .header("Content-Type", "application/json")
  .header("Authorization", "Bearer yourtoken123456")
  .body("{\"text\":\"hello world\",\"phone\":\"15551234567\"}")
  .asJson();

System.out.println(response.getBody());

OkHttp


import java.io.IOException;
import okhttp3.MediaType;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.RequestBody;
import okhttp3.Response;

// .....

String data = "{\"text\":\"hello world\",\"phone\":\"15551234567\"}";
MediaType jsonMediaType = MediaType.get("application/json; charset=utf-8");

RequestBody body = RequestBody.create(data, jsonMediaType);
String url = "https://api.jetapi.io/api/v1/delivery";
String accessToken = "yourtoken123456";

Request request = new Request.Builder()
  .url(url)
  .post(body)
  .addHeader("authorization", "Bearer " + accessToken)
  .build();

OkHttpClient client = new OkHttpClient();

try (Response response = client.newCall(request).execute()) {
  System.out.println(response.body().string());
} catch (IOException e) {
  e.printStackTrace();
}

cURL


<?php

$curl = curl_init();

curl_setopt_array($curl, array(
  CURLOPT_URL => "https://api.jetapi.io/api/v1/delivery",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "{\"text\":\"hello world\",\"phone\":\"15551234567\"}",
  CURLOPT_HTTPHEADER => array(
    "authorization: Bearer yourtoken123456",
    "content-type: application/json"
  ),
));

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

RestSharp


using System;
using RestSharp;
using System.Threading;
using RestSharp.Authenticators.OAuth2;

// .....

var access_token = "yourtoken123456";

var client = new RestClient("api.jetapi.io/api/v1/");
client.Authenticator = new OAuth2AuthorizationRequestHeaderAuthenticator(access_token, "Bearer");

var request_params = new
{
  text = "hello world",
  phone = "15551234567"
};

var request = new RestRequest("delivery").AddJsonBody(request_params);

try
{
  var response = await client.PostAsync(request);
  Console.WriteLine(response.Content);
}
catch(Exception e) {
  Console.WriteLine("{0} Exception caught.", e);

Net::HTTP


require 'uri'
require 'net/http'
require 'openssl'
require 'json'

url = URI('https://api.jetapi.io/api/v1/delivery')

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
http.verify_mode = OpenSSL::SSL::VERIFY_NONE # please use OpenSSL::SSL::VERIFY_PEER in production

request = Net::HTTP::Post.new(url)
request['authorization'] = 'Bearer yourtoken123456'
request['content-type'] = 'application/json'
request.body = { text: 'hello world', phone: '15551234567' }.to_json

response = http.request(request)
puts response.read_body

URL Loading System


import Foundation

let session = URLSession.shared
let url = URL(string: "https://api.jetapi.io/api/v1/delivery")!
let headers = [
  "Authorization": "Bearer yourtoken123456",
  "Content-Type": "application/json"
]
let parameters = [
  "text": "hello world",
  "phone": "15551234567"
]

var request = URLRequest(
  url: url,
  cachePolicy: .reloadIgnoringLocalCacheData
)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = try JSONSerialization.data(withJSONObject: parameters, options: [])

let dataTask = session.dataTask(
  with: request as URLRequest,
  completionHandler: { data, _response, error in
    if let error = error {
        print("Error: \(error)")
        return
    }

    if let data = data, let dataString = String(data: data, encoding: .utf8) {
        print(dataString)
    }
  }
)

dataTask.resume()

HTTPoison


params = %{text: "hello world", phone: "15551234567"}
url = "https://api.jetapi.io/api/v1/delivery"
token = "yourtoken123456"
request_headers = [
  {"Content-Type", "application/json"},
  {"Authorization", "Bearer #{token}"}
]

case HTTPoison.post(url, Jason.encode!(params), request_headers) do
  {:ok, %HTTPoison.Response{status_code: 200, body: resp_body}} ->
    IO.inspect(Jason.decode!(resp_body))

  {:ok, %HTTPoison.Response{body: resp_body}} ->
    IO.puts("Request error: #{resp_body}")

  {:error, %HTTPoison.Error{reason: reason}} ->
    IO.puts("Connection error: #{reason}")
end

Painel de controlo do programador

Navegue com facilidade por nosso Painel de Desenvolvedor, que apresenta uma lista abrangente de instâncias e um refinado controle de acesso à API.

Arranque em 3 passos

Desfrute de um preço fixo, sem taxas ocultas e com mensagens ilimitadas. Comece a utilizar em menos de 5 minutos!

Criar conta

Criar e gerir instâncias

Configurar e gerir instâncias através do painel de controlo da sua conta.

Integrar API

Siga a nossa documentação de fácil utilização para integrar sem problemas a JetAPI no seu serviço.

Criar conta

Registe-se e obtenha o seu Token de Programador.

Centro de mensagens tudo-em-um

Diga adeus à dificuldade de pular entre plataformas diferentes! Gerencie todas as conversas em uma única conta com nossa interface de usuário SaaS incorporada.

Armazenamento de dados centralizado

Todas as conversas e dados dos clientes são armazenados de forma segura num único local, eliminando o risco de perda de dados devido à rotação de funcionários.

Interface unificada

Acesse todas as suas mensagens de diferentes mensageiros em uma interface unificada, economizando tempo e reduzindo transtornos.

Experiência de comunicação consistente

Nosso hub oferece um conjunto consistente de recursos e uma interface unificada para todos os mensageiros, garantindo uma experiência de comunicação sem interrupções.