URA inteligente no WhatsApp: menu falado com IA em vez de "digite 1"

Uma URA inteligente no WhatsApp troca o "digite 1 para financeiro" por uma pergunta aberta — "como posso ajudar?" — e usa IA para entender a resposta falada e levar o cliente ao lugar certo. Com a API não oficial da WAME, você atende a chamada pela API, recebe a voz do cliente em tempo real pelo Socket.IO e toca gravações ou voz sintética de volta. Como não existe transferência para outro número, a URA resolve o que é simples na própria ligação e entrega o resto com um próximo passo claro: contato do setor por mensagem, ticket aberto ou retorno agendado.

É o meio-termo entre dois extremos já cobertos aqui: recusar a ligação e responder por texto e um agente de IA que conversa livremente.

A camada não oficial da WAME é independente e não é afiliada, endossada ou suportada pelo WhatsApp ou pela Meta. O uso é de responsabilidade de quem envia.

Por que não fazer uma URA de "digite 1"

Numa ligação de WhatsApp, o teclado numérico não é o caminho natural — e mesmo onde é, o cliente odeia ouvir oito opções para escolher a sétima. A URA por voz resolve isso de uma vez:

• o cliente fala do jeito dele ("quero a segunda via do boleto", "meu pedido não chegou");
• a IA classifica numa lista fechada de intenções;
• cada intenção tem uma ação definida.

É mais simples que um agente de voz completo: não há conversa longa, só entender e encaminhar. Por isso é um ótimo primeiro projeto de voz.

Definir as intenções

Comece pela lista, não pelo código. Olhe as últimas cem ligações (ou mensagens) e agrupe os motivos. Um exemplo para uma loja:

Seis intenções bem feitas valem mais que vinte mal definidas. E cada intenção termina em alguma ação concreta — nunca em "aguarde na linha".

A saudação: gravada, não gerada

A saudação é igual para todo mundo, então não faz sentido sintetizar a cada ligação. Grave uma vez (ou gere uma vez com voz sintética) e toque com o endpoint de áudio da chamada:

curl -X POST "https://us.api-wa.me/SUA_KEY/call/ID_DA_CHAMADA/audio" \
  -H "Content-Type: application/json" \
  -d '{ "url": "https://cdn.suaempresa.com/ura/saudacao.mp3" }'

A API aceita url, base64 ou file, converte para o formato da chamada e coloca na fila de reprodução. A conversão acontece uma vez por arquivo, então reutilizar as mesmas URLs é rápido.

Uma boa saudação faz três coisas em poucos segundos: diz quem atende, avisa que é um assistente virtual e faz uma pergunta aberta.

"Olá, você ligou para a Loja Exemplo. Eu sou a assistente virtual. Me diga em poucas palavras como posso ajudar."

Mantenha também gravados os áudios fixos de cada ramo ("Vou te mandar a segunda via por mensagem agora", "Nosso horário é de segunda a sexta, das 8h às 18h"). Só as partes variáveis — o status de um pedido específico, um prazo calculado — precisam de voz sintética na hora, enviada pelo evento call-audio-in em PCM 16 kHz.

O fluxo da URA

import express from 'express';
import { io } from 'socket.io-client';

const KEY = process.env.WAME_KEY;
const BASE = `https://us.api-wa.me/${KEY}`;
const AUDIO = 'https://cdn.suaempresa.com/ura';

const post = (path, body) =>
  fetch(`${BASE}${path}`, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify(body),
  }).then((r) => r.json());

const tocar = (callId, arquivo) => post(`/call/${callId}/audio`, { url: `${AUDIO}/${arquivo}` });

const chamadas = new Map();

const socket = io('https://us.api-wa.me', {
  auth: { key: KEY },
  query: { key: KEY },
  transports: ['websocket', 'polling'],
});

socket.on('call-audio', ({ callId, pcm }) => {
  chamadas.get(callId)?.detector.alimentar(Buffer.from(pcm, 'base64'));
});

const app = express();
app.use(express.json());

app.post('/webhook/wame', async (req, res) => {
  res.sendStatus(200);
  const change = req.body?.entry?.[0]?.changes?.[0];
  if (change?.field !== 'call') return;
  const ch = change.value?.calls?.[0];
  if (!ch || ch.status !== 'offer' || ch.is_group) return;

  if (!dentroDoHorario()) return foraDoHorario(ch);

  const jid = ch.from_jid ?? ch.from;
  await post('/call/accept', { callId: ch.id, callFrom: jid });
  chamadas.set(ch.id, {
    jid,
    telefone: ch.from,
    tentativas: 0,
    detector: criarDetectorDeFala((trecho) => rotear(ch.id, trecho)),
  });
  await tocar(ch.id, 'saudacao.mp3');
});

app.listen(3000);

O criarDetectorDeFala identifica quando o cliente terminou de falar; um exemplo simples está em IA para atender ligação no WhatsApp, e os ajustes finos, em latência, interrupção e silêncio.

Rotear pela intenção

async function rotear(callId, trecho) {
  const c = chamadas.get(callId);
  if (!c || c.ocupado) return;
  c.ocupado = true;
  try {
    const texto = await transcrever(trecho);             // seu provedor de STT
    const { intencao, dado } = await classificar(texto); // lista fechada de intenções
    c.ultimaFala = texto;

    switch (intencao) {
      case 'segunda_via':
        await enviarSegundaVia(c.telefone);               // mensagem com boleto/Pix
        await tocar(callId, 'segunda-via-enviada.mp3');
        return encerrar(callId);

      case 'status_pedido': {
        const status = await consultarPedido(c.telefone, dado);
        await falarSintetizado(callId, status);           // variável: voz sintética
        return encerrar(callId);
      }

      case 'financeiro':
      case 'falar_com_humano':
        await abrirTicket(c, intencao);
        await tocar(callId, 'retorno-agendado.mp3');
        return encerrar(callId);

      default:
        if (++c.tentativas >= 2) {
          await abrirTicket(c, 'outro');
          await tocar(callId, 'vamos-te-chamar.mp3');
          return encerrar(callId);
        }
        await tocar(callId, 'nao-entendi-opcoes.mp3');    // agora sim, lista as opções
    }
  } finally {
    c.ocupado = false;
  }
}

async function encerrar(callId) {
  const c = chamadas.get(callId);
  if (!c) return;
  chamadas.delete(callId);
  setTimeout(() => post('/call/end', { callId, peerJid: c.jid }), 5000); // deixa o áudio final tocar
}

Repare na segunda tentativa: se a IA não entendeu, aí sim a URA lista as opções em voz. É o melhor dos dois mundos — o cliente que sabe o que quer resolve de primeira, e quem não sabe ainda tem o menu.

A classificação é uma chamada curta a um modelo de linguagem com a lista de intenções e exemplos de frases. Peça resposta em JSON com um campo intencao restrito à lista, e trate qualquer coisa fora dela como outro.

Encaminhar sem transferir

Como a ligação não pode ser passada para outro número, o encaminhamento acontece por mensagem, no mesmo WhatsApp, logo depois:

• Contato do setor: envie o cartão de contato com POST /{key}/message/contact — o cliente salva e chama o setor certo. Veja enviar contato (vCard) pela API.
• Link de autoatendimento: segunda via, rastreio, política de troca.
• Ticket com resumo: o time recebe o motivo e o texto da fala do cliente, e retorna sem precisar perguntar tudo de novo.
• Retorno agendado: a URA oferece dois horários e registra.

Avise sempre na ligação o que vai acontecer: "Vou te mandar agora o contato do financeiro por mensagem." Cliente que desliga sabendo o próximo passo não liga de novo.

Fora do horário

Duas saídas razoáveis:

1. Atender com URA reduzida: toca o aviso de horário, resolve o que é automático (segunda via, status de pedido) e agenda retorno para o resto.
2. Recusar e responder por texto, como em recusar ligação automaticamente — mais barato e, para muita gente, suficiente.

O que não fazer: deixar tocar até cair. É a pior experiência possível e gera nova ligação, reclamação ou as duas.

Medir e melhorar

Registre por ligação: intenção detectada, ação tomada, se precisou de segunda tentativa e se o cliente voltou a ligar em 24 horas. Com isso você vê:

• quais intenções a IA confunde (e precisa de mais exemplos);
• quais ramos terminam em nova ligação (a ação não resolveu);
• que motivo novo está aparecendo e merece virar intenção.

Guarde o texto transcrito com retenção definida e avise no começo da ligação que ela pode ser transcrita. Os detalhes de registro estão em transcrever e resumir ligações com IA.

Uso certo

A URA existe para atender quem ligou. Ela não é ferramenta de ligação ativa para listas — isso é robocall, é denunciado e derruba número, e a WAME não apoia esse uso. Atendendo quem procurou a sua empresa, o risco de bloqueio é muito baixo.

Conclusão

Uma URA inteligente no WhatsApp é um projeto de voz com escopo fechado: entender o motivo da ligação numa lista curta de intenções e executar uma ação para cada uma. A API não oficial da WAME dá o atendimento pela API, a voz do cliente em tempo real pelo Socket.IO e duas formas de responder — arquivos gravados com POST /{key}/call/{callId}/audio e voz sintética pelo call-audio-in. Sem transferência de chamada, o encaminhamento acontece por mensagem, ticket ou retorno agendado, sempre anunciado antes de desligar. Os endpoints de chamada estão na documentação, e o básico de atender e ligar, em ligação pelo WhatsApp via API.