Chamadas de voz no WhatsApp com baileys-caller

A Cloud API oficial cobre o envio e o recebimento de mensagens, templates aprovados, midias e webhooks de status. Ela nao expoe um endpoint para o seu backend discar uma chamada de voz para um numero. Para alguns casos de uso (confirmar uma entrega por voz, fazer um callback automatico de atendimento, disparar um alerta que precisa tocar como uma ligacao), essa lacuna e um bloqueio real, e e ai que entram bibliotecas baseadas no protocolo do WhatsApp Web.

Baileys e uma biblioteca Node.js que fala o protocolo do WhatsApp Web via WebSocket. Ela nao e a Cloud API oficial: roda em cima de uma sessao pareada (como se fosse o seu WhatsApp Web), o que abre portas que a API oficial fecha, mas tambem traz riscos que a API oficial nao tem. O baileys-caller (https://github.com/SheIITear/baileys-caller) e um projeto focado em iniciar e gerenciar chamadas de voz e video em cima dessa sessao Baileys.

O Baileys nao usa HTTP REST como a Cloud API. Ele abre um WebSocket contra a infraestrutura do WhatsApp Web e mantem uma sessao autenticada, exatamente como o aplicativo WhatsApp Web faz no navegador. O pareamento acontece via QR code ou via pairing code (um codigo numerico digitado no celular). A partir dai, mensagens e eventos chegam por um fluxo de eventos assincrono.

Seu backend (Node.js)
        |
   [Baileys socket]  <== WebSocket ==>  WhatsApp Web infra
        |                                       |
   credenciais da sessao                   celular pareado
   (auth state salvo)                       (QR / pairing code)
        |
   eventos: connection.update, messages.upsert, call

A sessao precisa ser persistida (o chamado auth state) para nao exigir um novo pareamento a cada reinicio. Os eventos mais relevantes sao connection.update (estado da conexao), messages.upsert (mensagens) e os eventos de chamada, que sao justamente o que o baileys-caller estende para permitir originar a ligacao, e nao apenas observa-la.

O codigo abaixo e ilustrativo. Ele mostra o padrao geral de conexao com Baileys, autenticacao via pairing code e a ideia de iniciar uma chamada com o baileys-caller. Os nomes exatos de funcoes podem diferir da versao real do projeto, consulte sempre o repositorio (https://github.com/SheIITear/baileys-caller) antes de usar em qualquer ambiente.

// ILUSTRATIVO: a API real pode diferir. Verifique o repo.
// https://github.com/SheIITear/baileys-caller
const { makeWASocket, useMultiFileAuthState } = require('@whiskeysockets/baileys');
// Import ilustrativo do helper de chamadas:
const { makeCaller } = require('baileys-caller');

async function start() {
  const { state, saveCreds } = await useMultiFileAuthState('./auth');

  const sock = makeWASocket({
    auth: state,
    printQRInTerminal: false,
  });

  sock.ev.on('creds.update', saveCreds);

  // Pareamento via pairing code (sem QR), informe o numero do bot:
  if (!sock.authState.creds.registered) {
    const code = await sock.requestPairingCode('5511999999999');
    console.log('Digite este codigo no WhatsApp do celular:', code);
  }

  // Camada de chamadas (ilustrativa):
  const caller = makeCaller(sock);

  return { sock, caller };
}

Com a sessao ativa, voce inicia a chamada e trata os eventos de ciclo de vida. De novo, os nomes sao ilustrativos: o importante e o padrao de tratar ringing, accepted, rejected e timeout.

// ILUSTRATIVO: nomes de metodos/eventos podem variar.
async function ligar(caller, destino) {
  // destino no formato JID do WhatsApp, ex: '[email protected]'
  const call = await caller.offerCall(destino, { video: false });

  call.on('ringing', () => console.log('Tocando no destino...'));
  call.on('accepted', () => console.log('Chamada aceita.'));
  call.on('rejected', () => console.log('Chamada rejeitada.'));
  call.on('timeout', () => console.log('Sem resposta (timeout).'));

  // Encerrar apos um limite, evitando chamada pendurada:
  setTimeout(() => call.hangup().catch(() => {}), 45000);
}

Usar uma biblioteca nao oficial nao e gratuito em termos de risco. O ponto mais importante: o WhatsApp pode banir o numero usado, sem aviso e sem recurso pratico. Trate isso como uma certeza eventual, nao como uma possibilidade remota, e desenhe o sistema para sobreviver a ela.

• ToS do WhatsApp: originar chamadas via Baileys esta fora dos termos de uso oficiais. Avalie o risco juridico e de marca antes de seguir.
• Risco de ban do numero: use um numero dedicado e descartavel, nunca o numero principal do negocio ou um numero pessoal.
• Instabilidade do protocolo: quando o WhatsApp muda o protocolo do Web, a biblioteca pode parar de funcionar ate ser atualizada. Tenha um plano para indisponibilidade.
• Rate limit proprio: limite a frequencia de chamadas (por minuto e por destino) para nao parecer comportamento automatizado abusivo, que acelera o ban.
• Consentimento do destinatario: so ligue para quem aceitou receber chamadas. Chamadas nao solicitadas geram denuncias, que tambem aceleram o ban.
• Sessao isolada: rode a sessao Baileys isolada, com auth state protegido, para conter o impacto se a credencial vazar.

A regra pratica e simples: so use baileys-caller se o valor de negocio justificar o risco de ban e a manutencao continua. Para producao critica, prefira sempre um canal de voz oficial (telefonia, SIP, provedores de voz) e deixe o WhatsApp para mensagens via Cloud API.

• Use se: for um piloto, um caso de uso de baixo volume, com numero dedicado e tolerancia explicita a quedas e ban.
• Use se: o valor da chamada por voz no WhatsApp for alto o suficiente para compensar a infra e a manutencao continua.
• NAO use se: o fluxo for critico para receita ou compliance e nao puder tolerar indisponibilidade ou perda do numero.
• NAO use se: existir um canal de voz oficial (telefonia ou provedor de voz) que atenda o mesmo caso de uso com previsibilidade.
• NAO use se: voce nao puder garantir consentimento do destinatario e rate limit responsavel.

Se a decisao for seguir, contenha o risco com arquitetura. O objetivo e isolar a parte fragil e nao oficial do resto do sistema, com fallback claro e observabilidade.

1. Isole a sessao Baileys em um worker dedicado, separado da sua API principal, com o auth state em armazenamento protegido.
2. Coloque as chamadas atras de uma fila, para controlar concorrencia, aplicar rate limit e nunca disparar tudo de uma vez.
3. Defina um fallback explicito: se a sessao Baileys cair ou o numero for banido, caia para a Cloud API (mensagem) ou para SMS / telefonia.
4. Registre logging estruturado de cada chamada (destino mascarado, status, duracao, motivo de falha) para auditar e detectar degradacao cedo.
5. Monitore a saude da sessao (connection.update) e alerte quando o pareamento cair, para reagir antes que a fila acumule.