Pular para o conteúdo
D-APITestar grátis

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:

  1. O backend inicia a chamada. dapi.calls.stream() (ou POST /api/v1/calls/stream) devolve callId e wsUrl. Só esses dois vão para o navegador.
  2. O navegador abre a chamada. LiveCall.connect() pede o microfone, abre o WebSocket de controle e já toca o áudio por ele.
  3. 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.
  4. 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.

A gente também é SaaS

SaaS liberado pelo time testa 14 dias grátis, com um grupo de onboarding em que o time técnico da D-API acompanha a integração no seu produto.

Continue por aqui

Liberar seu teste grátis

Responda rapidinho e o time libera seu teste pelo WhatsApp, com o time técnico ajudando na integração.

Seus dados são usados só pra liberar o teste. Sem spam.