webrtc no navegador
Ligação de WhatsApp no navegador com WebRTC, sem instalar nada no atendente
A ligação de WhatsApp no navegador com WebRTC deixa o usuário do seu SaaS falar pelo painel, com microfone e fone do computador, áudio Opus que aguenta Wi-Fi instável e volta sozinho para o WebSocket se a rede bloquear.
SaaS testa 14 dias com o time técnico ajudando na integração.
- conexões na D-API
- 1.875
- de uptime garantido em contrato
- 99,9%
- datacenters no Brasil
- 4
- por ligação de WhatsApp na API não-oficial
- R$ 0
Opus com correção de perda
O áudio vai por UDP com Opus e FEC, que suporta rede ruim, Wi-Fi instável e 4G melhor que o áudio por WebSocket.
Fallback sem derrubar a chamada
Se o WebRTC não conectar ou cair, o áudio volta para o WebSocket e o SDK tenta de novo em segundo plano.
Uma linha no front-end
LiveCall.connect(callId, wsUrl, { transport: "webrtc" }) pede o microfone, toca o áudio e trata o ciclo de vida.
Chave fora do navegador
O backend inicia a chamada com a API key; a página recebe só callId e wsUrl, com token exclusivo daquela ligação.
A ligação de WhatsApp no navegador é o que transforma o seu SaaS num telefone de verdade para o atendente. Ele está no painel do CRM, clica em “ligar”, fala pelo headset do computador e o contato atende no WhatsApp do celular. Na D-API, o transporte recomendado para esse áudio é o WebRTC, o mesmo padrão que os navegadores usam em videoconferência, e ele vem embutido no d-api-sdk.
A escolha do transporte importa mais do que parece. Áudio por WebSocket roda sobre TCP: quando um pacote atrasa, tudo atrás dele espera, e a voz picota. O WebRTC manda o áudio por UDP com Opus e correção de perda (FEC), então um pacote perdido vira um trecho reconstruído em vez de um silêncio. Em Wi-Fi de recepção de clínica ou 4G de vendedor externo, a diferença é audível.
As ligações fazem parte das ligações WhatsApp API da D-API e não têm custo por chamada na conexão não-oficial.
Como a ligação de WhatsApp no navegador funciona
O fluxo tem quatro etapas, e só a primeira envolve a sua API key:
- O backend inicia a chamada.
dapi.calls.stream()(ouPOST /api/v1/calls/stream) devolvecallIdewsUrl. Só esses dois vão para o navegador. - O navegador abre a chamada.
LiveCall.connect()pede o microfone, abre o WebSocket de controle e já toca o áudio por ele. - O áudio passa para o WebRTC. Em menos de um segundo, o SDK negocia o WebRTC e move o áudio para ele. Eventos, mudo e desligar continuam no WebSocket.
- Se a rede bloquear, o áudio volta. O SDK devolve o áudio ao WebSocket sem derrubar a chamada e tenta o WebRTC de novo em segundo plano.
Para o atendente, nada disso aparece. Durante uma troca de caminho, o áudio para por poucos segundos e a chamada continua.
O código, em duas partes
Uma rota no seu backend guarda a chave e autentica o seu usuário:
// server.js
import express from "express";
import { DApi } from "d-api-sdk";
const dapi = new DApi({ apiKey: process.env.DAPI_API_KEY });
const app = express();
app.use(express.json());
app.post("/api/call", async (req, res) => {
// autentique o SEU usuário antes de ligar em nome dele
const { callId, wsUrl } = await dapi.calls.stream({
sessionId: req.body.sessionId,
phone: req.body.phone, // DDI + DDD + número, só dígitos
});
res.json({ callId, wsUrl });
});
E a página abre a chamada dentro de um clique:
// call.js
import { LiveCall } from "d-api-sdk";
let call = null;
document.querySelector("#ligar").onclick = async () => {
const { callId, wsUrl } = await fetch("/api/call", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({ sessionId: "minha-sessao", phone: "5511999999999" }),
}).then((r) => r.json());
call = await LiveCall.connect(callId, wsUrl, { transport: "webrtc" });
call.on("event", (e) => setStatus(e.type)); // calling, ringing, accepted...
call.on("transport", (t) => console.log("áudio via", t.transport, t.reason ?? ""));
call.on("ended", (e) => setStatus(`encerrada ${e.reason ?? ""}`));
call.on("recording", (r) => salvarGravacao(r.url));
};
document.querySelector("#mudo").onclick = () => call?.mute(true);
document.querySelector("#desligar").onclick = () => call?.hangup();
O SDK toca a voz do contato e só envia o áudio do atendente depois que a pessoa atende. Para o seu time de front-end, o trabalho é desenhar os estados: chamando, tocando, em chamada, encerrada e erro.
As opções que você vai ajustar
| Opção | Padrão | Efeito |
|---|---|---|
transport |
"websocket" |
"webrtc" move o áudio para o WebRTC (recomendado) |
fallback |
true |
Fica no WebSocket quando o WebRTC falha; false encerra a chamada |
audio |
"device" no navegador |
O SDK cuida de microfone e alto-falante; "pcm" entrega o áudio ao seu código |
webrtcConnectTimeoutMs |
10000 |
Tempo para o WebRTC conectar antes de cair para o WebSocket |
resume |
true |
Reconecta o WebSocket se a rede cair, sem perder a chamada |
O fallback: false serve a quem prefere falhar a chamada a ter áudio por TCP, por exemplo num produto que mede qualidade de voz. Para a maioria dos SaaS de atendimento, o padrão é o certo.
Quando o WebRTC cai, o evento explica
O evento transport diz por onde o áudio está indo e por quê. Isso vale ouro para o seu suporte: em vez de “a ligação ficou ruim”, o log mostra o motivo.
reason |
O que aconteceu | O SDK tenta de novo? |
|---|---|---|
webrtc_disconnected, webrtc_failed |
A rede caiu ou bloqueou o UDP | Sim, com intervalo crescente de 2 s até 30 s |
ice_timeout, signal_timeout, gateway_error, at_capacity |
O WebRTC não conectou desta vez | Sim |
unavailable |
WebRTC indisponível no servidor | Não |
unsupported_runtime |
Ambiente sem WebRTC | Não |
Uma boa prática é registrar o transport de cada chamada junto do callId. Se um cliente do seu SaaS reclama de áudio, você sabe se o escritório dele bloqueia UDP antes de abrir chamado.
Atender no navegador também
Chamadas recebidas usam o mesmo caminho. O seu backend atende com dapi.calls.accept({ sessionId, callId, from }), recebe { callId, wsUrl } e entrega à página, que chama LiveCall.connect() do mesmo jeito. O fluxo de assinatura das ofertas está em receber ligações de WhatsApp pela API, e o desenho de um painel completo de atendentes, em central de atendimento com ligações de WhatsApp.
Fora do navegador e em outras linguagens
No Node, o mesmo SDK entrega o áudio cru ao seu código, PCM s16le de 16 kHz, mono, em frames de 20 ms, o que serve a bots e agentes de IA. O WebRTC no Node usa um pacote opcional; sem ele, transport: "webrtc" continua funcionando pelo WebSocket.
Para outra linguagem, o protocolo roda no mesmo WebSocket da wsUrl:
| Você envia | A D-API responde |
|---|---|
{"type":"webrtc.config"} |
{"type":"webrtc.config","iceServers":[...]} |
{"type":"webrtc.offer","sdp":"..."}, offer completa com trilha Opus |
{"type":"webrtc.answer","sdp":"..."} |
{"type":"media","transport":"webrtc"}, com o peer conectado |
O áudio passa só pelo WebRTC |
{"type":"media","transport":"websocket"} |
O áudio volta para o WebSocket |
Se algo falhar, chega {"type":"webrtc.error","code":"..."} e o áudio segue no WebSocket. Quem nunca envia essas mensagens continua no fluxo descrito em stream de áudio da ligação de WhatsApp. O guia completo, com a migração do WebSocket manual, está na documentação da D-API.
Time D-API. Atualizado em .
Perguntas frequentes
Funciona em rede corporativa que bloqueia UDP?
Funciona pelo WebSocket. Quando o WebRTC não conecta, o SDK mantém o áudio no WebSocket, que passa em redes que bloqueiam UDP. O evento transport informa por qual caminho o áudio está indo e o motivo da troca.
Preciso de servidor de mídia próprio?
Não. A D-API negocia o WebRTC do lado dela e entrega a configuração ICE quando a página pede. O seu backend só inicia ou atende a chamada e repassa callId e wsUrl ao navegador.
Posso usar WebRTC fora do JavaScript?
Sim. O protocolo é aberto e documentado: no mesmo WebSocket da wsUrl você pede a configuração ICE, envia a offer SDP com uma trilha Opus, recebe a answer e troca o transporte de mídia. Qualquer biblioteca WebRTC serve.
A gravação e os webhooks mudam com WebRTC?
Não. Eventos, webhooks call.* e gravação são os mesmos do WebSocket. Só o caminho do áudio muda.
O navegador precisa de alguma condição?
A página precisa estar em HTTPS, ou localhost em desenvolvimento, e a chamada deve começar a partir de um clique, porque os navegadores só liberam áudio depois de uma ação do usuário.