---
title: "URA inteligente no WhatsApp: menu falado com IA em vez de \"digite 1\""
description: "URA inteligente nas ligações do WhatsApp pela API: o cliente diz o que precisa, a IA entende, resolve, manda o contato do setor ou agenda retorno."
url: "https://wame.api.br/blog/ura-inteligente-whatsapp-ligacao"
language: "pt-BR"
og:type: "article"
published_time: "2026-09-28"
modified_time: "2026-09-28"
author: "Raphael Serafim"
keywords: "ura inteligente whatsapp, ura com ia, ligação whatsapp api, api whatsapp não oficial, api não oficial whatsapp, atendimento telefônico whatsapp, menu de voz whatsapp"
reading_time: "9 min de leitura"
---

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

> URA inteligente nas ligações do WhatsApp pela API: o cliente diz o que precisa, a IA entende, resolve, manda o contato do setor ou agenda retorno.

**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](/blog/recusar-ligacao-whatsapp-automatico-api) e um [agente de IA que conversa livremente](/blog/ia-atender-ligacao-whatsapp-api).

> 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:

| Intenção | Ação na URA |
| --- | --- |
| `status_pedido` | Pede o número do pedido, consulta e responde em voz |
| `segunda_via` | Envia o boleto ou Pix por mensagem durante a ligação |
| `troca_devolucao` | Explica a política em uma frase e manda o link por mensagem |
| `financeiro` | Abre ticket com resumo e agenda retorno do setor |
| `falar_com_humano` | Abre ticket prioritário e avisa o prazo de retorno |
| `outro` | Pergunta de novo uma vez; depois, ticket genérico |

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:

```bash
curl -X POST "https://server.wame.api.br/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

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

const KEY = process.env.WAME_KEY;
const BASE = `https://server.wame.api.br/${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://server.wame.api.br', {
  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](/blog/ia-atender-ligacao-whatsapp-api), e os ajustes finos, em [latência, interrupção e silêncio](/blog/agente-voz-whatsapp-latencia-interrupcao).

## Rotear pela intenção

```js
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](/blog/enviar-contato-vcard-whatsapp-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](/blog/recusar-ligacao-whatsapp-automatico-api) — 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](/blog/transcrever-resumir-ligacao-whatsapp-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](/docs), e o básico de atender e ligar, em [ligação pelo WhatsApp via API](/blog/fazer-ligacao-whatsapp-api-nao-oficial).

## Perguntas frequentes

### O que é uma URA inteligente no WhatsApp?

É um atendimento de voz que, em vez de pedir para digitar 1, 2 ou 3, pergunta o que a pessoa precisa e entende a resposta falada com IA. Nas ligações do WhatsApp, a API não oficial da WAME atende a chamada, entrega a voz do cliente em tempo real pelo Socket.IO e permite tocar áudios gravados ou gerados na hora.

### A URA consegue transferir a ligação para o setor certo?

Não há transferência de chamada para outro número. A URA resolve de outro jeito: responde o que for simples, envia por mensagem o contato ou link do setor, abre um ticket com o resumo ou agenda um retorno do time. Para o cliente, o importante é sair da ligação com o próximo passo claro.

### Posso usar áudios gravados na URA?

Sim. Envie o arquivo com POST /{key}/call/{callId}/audio, por url ou base64; a API converte qualquer formato de áudio para o formato da chamada. Gravações funcionam bem para saudação, aviso de horário e mensagens fixas. Para respostas variáveis, use voz sintética em tempo real pelo evento call-audio-in.

### O que a URA faz fora do horário de atendimento?

Pode atender, avisar o horário, resolver o que é automático (segunda via, status de pedido) e agendar retorno. Ou pode recusar a ligação e responder por mensagem na hora. As duas saídas são melhores que deixar o telefone tocando sem resposta.

### Quantas opções a URA deve ter?

Poucas intenções bem definidas, geralmente entre quatro e oito. A vantagem da URA com IA é que o cliente não precisa ouvir o menu inteiro: ele diz o que quer. Mas se a IA não entender duas vezes, ofereça as opções em voz ou siga por mensagem.
