Instalação AstraCalls padrão

Link: https://github.com/AstraOnlineWeb/AstraCalls/tree/main

git clone https://github.com/AstraOnlineWeb/AstraCalls.git

📞 AstraCalls

Chamadas de voz e vídeo do WhatsApp em Go puro, direto do navegador — prontas para produção SaaS.

VoIP nativo (áudio + vídeo, 1:1 e em grupo), gateway SIP/PBX, suíte completa de mensagens, disparos, webhooks confiáveis, integração com Chatwoot e deploy em Docker Swarm + Traefik.

Visão Geral · Funcionalidades · Arquitetura · Início Rápido · Configuração · Deploy · API · n8n · Suporte

📋 Visão Geral

O AstraCalls pareia uma ou mais contas do WhatsApp (QR code, código de pareamento ou passkey) e permite fazer e receber chamadas de voz e vídeo de qualquer navegador, ligar para tronco/ramal SIP, e operar a conta como canal de mensagens (texto, mídia, botões, listas, carrossel, enquete, formulário, pix, produto, status…).

O microfone e a câmera do navegador chegam ao servidor Go por WebRTC (ou por WebSocket, com fallback automático quando o WebRTC não passa no firewall). O servidor transcodifica para os codecs do WhatsApp (MLow para voz, H.264 para vídeo) e injeta a mídia na malha de relay SRTP do WhatsApp — e o caminho inverso traz o áudio e o vídeo do outro lado de volta ao navegador.

Toda a pilha VoIP roda nativamente em Go: codec MLow, RTP/SRTP/SRTCP, STUN, transporte SCTP/DTLS do relay, pipeline H.264 e a sinalização `<call>`, integrados ao whatsmeow e servidos a um painel React 19. A única dependência em C é o codec `opus_mlow` (via cgo) — e é opcional: sem ela o servidor roda em modo somente sinalização.

Várias contas podem ser pareadas e operadas lado a lado, cada uma com QR, status, histórico e banco próprios. Uma conta mantém várias chamadas 1:1 simultâneas (uma por atendente), roteadas por call ID.

Status: estável e em produção (última versão estável no CHANGELOG). Chamada em grupo é funcional (áudio + vídeo, 3+ participantes) mas segue marcada como experimental, atrás da flag WACALLS_GROUP_CALLS.

🚀 Funcionalidades

☎️ Chamadas de voz

Saída e entrada 1:1 com áudio bidirecional, várias chamadas simultâneas por conta.
Espera (hold/resume) com música, atender em espera e transferência cega entre atendentes (troca de dono + ponte, sem tocar a perna do WhatsApp).
Mudo / mão levantada (mute_v2, raise_hand) nos dois sentidos.
Timeout de toque, recusa que para o telefone de quem ligou, consent freshness (RFC 7675) — a chamada não cai sozinha aos ~20s.
Toque fantasma (POST /calls/fake): liga e desliga antes de atender (aviso/alerta).
Transporte de áudio no navegador: WebRTC com fallback automático para WebSocket (WACALLS_DEFAULT_TRANSPORT=auto|webrtc|websocket); WS de áudio PCM16 full-duplex (GET /calls/{id}/ws) pronto para agentes de voz/IA.
Gravação opt-in por sessão: MP3 mono mixado dos dois lados, vira nota privada no Chatwoot e evento recording no webhook.

📹 Chamadas de vídeo

Vídeo 1:1 (câmera do atendente e do cliente), upgrade/downgrade no meio da chamada (áudio → vídeo e volta), religar a câmera, MediaClock (áudio e vídeo no mesmo relógio).
Orientação automática (lê a rotação do celular no RTP e no stanza <video>) com botão de girar como ajuste manual, no painel e no widget.
Vídeo no widget do Chatwoot (WebCodecs, data channel H.264).
Disparo de ligações de VÍDEO com arquivo gravado (POST /broadcast {video:true}).

👥 Chamada em grupo (experimental, `WACALLS_GROUP_CALLS=1`)

Liga para um grupo existente (resolve os membros) com áudio e vídeo; o atendente ouve o mix de todos e fala para todos; vê a câmera de cada participante em tiles rotulados com número + nome.
Protocolo completo do grupo: offer com group_info, chave de epoch compartilhada com rotação a cada entrada, relay de grupo (DTLS direto, SFU com HBH-FEC), SRTCP (Sender Reports + PLI/pedido de keyframe nos dois sentidos), anúncio <video state>, participante que sai some do painel.
Endpoints POST /calls/group, /calls/group/end, WS /calls/group/ws (áudio PCM16) e /calls/group/video-ws (H.264), GET /calls/group/roster.

☎️ Gateway SIP / PBX

Servidor SIP (porta 5060 UDP/TCP) para o PBX/softphone do cliente se registrar no AstraCalls (credenciais por sessão, mostradas no painel) — tronco ↔ WhatsApp nos dois sentidos, áudio G.711 ↔ MLow.
Registro em PBX externo (o AstraCalls vira um ramal do Asterisk/FreePBX/tronco hospedado), com servidor, domínio e outbound proxy separados, re-REGISTER automático e status no painel.
RTP em faixa fixa de portas (WACALLS_RTP_PORT_MIN/MAX), publicável em mode=host.

📞 Conector SIP (PABX IP → AstraChat) — serviço separado

Binário sipconnector na mesma imagem: liga qualquer PABX IP ao AstraChat, sem WhatsApp.
Linha por caixa (o PABX registra no conector ou o conector registra no PABX) e um ramal por atendente (e-mail → ramal).
Expõe a mesma API de chamadas do wacalls (SSE, accept/reject/DELETE, /webrtc para o navegador em PCMU sem transcodificar, /ws pcm16 para o agente de voz por IA) e transferência para ramal por SIP REFER.
Detalhes, variáveis e deploy: cmd/sipconnector/README.md.

💬 Mensagens (API estilo WAHA, ~60 endpoints)

Envio: texto, imagem, áudio/nota de voz (com waveform), vídeo, nota de vídeo (PTV), documento, sticker, contato, localização, link com preview, enquete (e voto), evento (e resposta), pix (BR Code), produto, status (texto/imagem/vídeo/áudio).
Interativas que renderizam no número não-oficial: interactive (CTA: abrir URL, copiar código, ligar, resposta rápida), buttons, list, carousel e formulário (webview) com respostas no Chatwoot + webhook form_response.
Mensagem que some após leitura (disappearing), mensagens temporárias por chat.
Editar, reagir, encaminhar, marcar como lida, digitando/gravando, presença.
Agendamento (/schedule, persiste e sobrevive a restart), envio idempotente (X-Message-ID), busca no histórico, download de mídia recebida.
Contatos, grupos, canais, perfil, privacidade, bloqueio, proxy por sessão.

📢 Disparos em massa

POST /blast: campanha de texto/imagem com pacing anti-ban, status e cancelamento.
POST /broadcast: disparo de ligações (áudio ou vídeo) tocando um arquivo gravado.
GET /restriction-status: detecta restrição/shadow-ban da conta (reachout_timelock).

🔔 Webhooks confiáveis

Eventos por sessão (message, receipt, call_*, recording, form_response, group_participants, restriction…), filtro de eventos, assinatura HMAC-SHA256 (X-Webhook-Signature), retry com backoff, circuit breaker, DLQ com replay.

🤝 Chatwoot

Contato/conversa por telefone, mensagens WhatsApp ↔ Chatwoot (texto + mídia) com 1 QR só por número; grupos e canais (opcionais); assinatura do atendente, always online, marcar lidas; importar histórico sob demanda; mensagem editada, origem de anúncio (Click to WhatsApp), nota privada da gravação.
Widget de chamada (widget.js): botão de telefone na conversa, toca e abre sozinho na chamada recebida, áudio por WebRTC ou WebSocket, vídeo, token de widget por conta.
Correção do 9º dígito BR / LID em todos os envios; sem contato "lixo" com LID.

🔐 Pareamento e segurança

Pareamento por QR, código (/pair-code) e passkey (/pair-passkey, com extensão de navegador própria em passkey-extension/).
API key (X-API-Key), tokens de widget assinados, guarda anti-SSRF no download de mídia por URL, escopo por conta nos eventos SSE.

📊 Observabilidade e infra

GET /livez, /readyz, /metrics (Prometheus), versão/commit do build em GET /api/config e no painel.
PostgreSQL por sessão (estilo WAHA), imagem multi-arch (amd64 + arm64) publicada pelo CI em Docker Hub.

🏗️ Arquitetura

┌──────────────────────────────────────────────────────────────────────────────┐
│          NAVEGADOR (painel React)   +   Widget no Chatwoot   +   PBX/SIP      │
│   mic/câmera · WebRTC (Opus + H.264 DC) ou WebSocket (PCM16) · HTTP + SSE     │
└──────────────────────────────────┬───────────────────────────────┬───────────┘
                                   │ /api/sessions/{sid}/calls/…    │ SIP 5060 + RTP
                                   ▼                               ▼
┌──────────────────────────── GO SERVER (cmd/server) ──────────────────────────┐
│  SessionManager  contas (whatsmeow client + CallManager + GroupCallManager)  │
│  Broker          SSE escopado por conta (sessões, chamadas, vídeo, ações)    │
│  Bridge / WS     pion WebRTC ou WebSocket ⇄ PCM 16 kHz / H.264               │
│  SIP Gateway     sipgo (UAS + UAC), ponte RTP G.711 ⇄ PCM                    │
│  Messaging       ~60 endpoints de envio, agendamento, blast, broadcast       │
│  Webhook         retry/backoff, circuit breaker, DLQ, HMAC                   │
│  Chatwoot        integração bidirecional + widget + import de histórico      │
│  Recorder        MP3 por chamada (ffmpeg)                                    │
│                                                                              │
│  internal/wa     adaptador VoipSocket sobre o whatsmeow                      │
│  internal/voip   call (1:1 + grupo) · signaling · media (MLow, SRTP/SRTCP,   │
│                  cripto de grupo) · transport (relay SCTP/DTLS, STUN, H.264) │
└────────────────┬─────────────────────────────────────┬────────────────────────┘
                 │ sinalização <call>                   │ mídia SRTP / H.264
                 ▼                                      ▼
        ┌────────────────┐                  ┌───────────────────────────┐
        │  WhatsApp WS   │                  │  relay do WhatsApp (1:1)  │
        │  (whatsmeow)   │                  │  relay de GRUPO (SFU)     │
        └────────────────┘                  └───────────────────────────┘
                                                        │
                                             ┌─────────────────────────┐
                                             │  PostgreSQL 16          │
                                             │  wacalls_main + 1/sessão│
                                             └─────────────────────────┘

Estrutura

Caminho	Responsabilidade
`cmd/server`	HTTP/SSE, sessões + store (Postgres), ponte WebRTC/WS, auth, mensagens, agendamento, blast/broadcast, webhook, Chatwoot, gravação, SIP (`sip_gateway.go`, `sip_uac.go`, `sip_rtp.go`), grupo (`groupcall.go`)
`internal/wa`	`VoipSocket` — envia/recebe stanzas `<call>` via whatsmeow
`internal/voip/core`	Tipos de domínio, constantes, interface `VoipSocket`
`internal/voip/wanode`	Helpers de node WhatsApp e JID
`internal/voip/media`	Codec MLow, RTP, SRTP/SRTCP, SSRC, resampling, derivação de chaves (1:1 e epoch de grupo)
`internal/voip/transport`	Relay SCTP (1:1), relay de grupo (DTLS direto + Allocate de grupo), STUN, empacotamento H.264
`internal/voip/signaling`	Build/parse de `<call>` (offer/accept/vídeo/grupo/rekey), cripto da call-key
`internal/voip/call`	`CallManager` (1:1) e `GroupCallManager` (grupo), pipeline de vídeo, mixer de áudio
`client/`	Painel React 19 + Vite + Tailwind v4 + shadcn/ui (discador, chamadas, vídeo, grupo, sessões, SIP, Chatwoot, histórico, login)
`client/public/widget.js`	Widget de chamada (áudio + vídeo) embutível no Chatwoot
`client/public/openapi.yaml` · `api-docs.html`	Documentação OpenAPI/Swagger da API (`/api-docs.html` no servidor)
`passkey-extension/`	Extensão Chrome para pareamento por passkey

⚙️ Início Rápido

git clone https://github.com/AstraOnlineWeb/AstraCalls.git
cd AstraCalls
git submodule update --init          # codec opus_mlow (necessário p/ áudio ao vivo)

go mod download                      # dependências Go
cd client && npm install && cd ..    # dependências do painel React

É preciso um PostgreSQL (usuário com CREATEDB):

export WACALLS_PG_URL='postgres://wacalls:senha@127.0.0.1:5432/postgres?sslmode=disable'

Rodar (somente sinalização — sem compilador C; pareia e chama, sem áudio)

go run ./cmd/server -addr :8080          # adicione -debug para logs verbosos

Rodar (áudio ao vivo — codec MLow nativo via cgo)

CGO_ENABLED=1 \
CGO_LDFLAGS="-L$PWD/native -Wl,-rpath,$PWD/native" \
go run -tags mlow ./cmd/server -addr :8080 -debug

O áudio real exige cgo + native/libopus_mlow.so (compilada de opus_mlow). A imagem Docker já vem com tudo.

Abra http://localhost:8080, clique em Nova sessão e escaneie o QR em WhatsApp → Aparelhos conectados (ou use código de pareamento / passkey).

Painel React em modo dev

cd client
npm run dev      # Vite na :5173, faz proxy de /api → http://localhost:8080

🔧 Configuração

Flags

Flag	Padrão	Significado
`-addr`	`:8080`	Endereço HTTP
`-pg-url` / `-pg-namespace`	env	URL do Postgres e prefixo dos bancos por sessão
`-static`	`client/dist`	Diretório do painel estático
`-debug`	`false`	Logs verbosos (inclui o log interno do whatsmeow)
`-max-calls-per-session`	`8`	Chamadas simultâneas por sessão (`0` = ilimitado)

Variáveis de ambiente

Env	Padrão	Significado
`WACALLS_PG_URL`	—	URL de manutenção do Postgres (usuário com `CREATEDB`)
`WACALLS_PG_NAMESPACE`	`wacalls`	Prefixo dos bancos (`wacalls_main` + `wacalls_<id>`)
`WACALLS_API_KEY`	—	Se setada, exige `X-API-Key` em `/api/` (use em produção*)
`WACALLS_PUBLIC_IP`	—	IP público p/ NAT 1:1 / ICE-TCP / SDP do SIP. `auto` descobre o IP real mesmo dentro do Docker/NAT de nuvem (interface pública → STUN → HTTPS); o IP achado e a fonte aparecem em `GET /api/config` (`publicIp`, `publicIpSource`)
`WACALLS_UDP_PORT`	—	Porta de mídia WebRTC (UDP + ICE-TCP)
`WACALLS_DEFAULT_TRANSPORT`	`auto`	Transporte de áudio do navegador: `auto` (WebRTC → fallback WS), `webrtc`, `websocket`
`WACALLS_MAX_CALLS`	`8`	Equivalente a `-max-calls-per-session`
`WACALLS_RING_TIMEOUT_SECONDS`	—	Expira chamada recebida que nunca é encerrada
`WACALLS_UNIFIED_SESSION_MINUTES`	`5`	Intervalo mínimo entre os sinais "unified session" enviados ao conectar, como faz o WhatsApp Web (`0` desliga)
`WACALLS_DEVICE_NAME`	`Windows`	Nome do aparelho em "Dispositivos conectados" (vale para pareamentos novos)
`WACALLS_DEVICE_BROWSER`	`chrome`	Ícone/plataforma do aparelho: `chrome`, `edge`, `firefox`, `safari` ou `desktop`
`WACALLS_RECORDING_DIR`	`$TMPDIR/wacalls-recordings`	Onde ficam os MP3s (retenção ~48h)
`WACALLS_PUBLIC_BASE_URL`	—	Base pública p/ URLs de gravação, formulários e widget (ex.: `https://call.seudominio.com`)
`WACALLS_WIDGET_KEY`	—	Chave-mestra para emitir tokens de widget (`POST /api/widget-tokens`)
`WACALLS_WIDGET_SIGNING_SECRET`	—	Segredo de assinatura dos tokens de widget
`WACALLS_SIP_ADDR`	`0.0.0.0:5060`	Endereço do servidor SIP (UDP + TCP)
`WACALLS_SIP_ADVERTISE_PORT`	`5060`	Porta SIP anunciada no `Contact` (registro em PBX externo)
`WACALLS_RTP_PORT_MIN` / `_MAX`	`40000` / `40049`	Faixa fixa de portas RTP do SIP (publique em `mode=host`)
`WACALLS_SIP_DEBUG`	off	Logs detalhados de mídia SIP/grupo (só para diagnóstico — gera muito log)
`WACALLS_GROUP_CALLS`	off	`1` liga a chamada em grupo (experimental)

Gravação de chamada (opt-in por sessão). Ligue em PUT /api/sessions/{sid}/recording {"enabled":true} (ou pelo toggle "Gravar" no painel). O áudio dos dois lados é mixado num MP3 mono 16 kHz que vira nota privada no Chatwoot e evento recording no webhook; o arquivo fica em GET /recordings/{callId}.mp3. Requer ffmpeg (já na imagem).

🐳 Deploy em produção (Docker Swarm + Traefik)

A imagem oficial é multi-arquitetura (linux/amd64 + linux/arm64) e é publicada pelo CI a cada push: astraonline/astracalls:develop (contínua) e astraonline/astracalls:vX.Y.Z

:latest (releases).

# deploy da stack (Postgres + servidor em rede de host + proxy Traefik)
docker stack deploy -c sua-stack.yml astracalls

# atualizar para a imagem mais nova
docker service update --image astraonline/astracalls:develop --force astracalls_astracalls

Notas de produção:

O servidor roda em rede de host para a mídia WebRTC/SIP enxergar a interface real.
Um serviço socat com labels do Traefik publica o HTTP em HTTPS (necessário porque getUserMedia só funciona em contexto seguro).
O PostgreSQL dedicado escuta apenas em 127.0.0.1 (não exposto à internet).
Defina WACALLS_PUBLIC_IP (ou auto), WACALLS_UDP_PORT, WACALLS_PG_URL, WACALLS_PUBLIC_BASE_URL e uma WACALLS_API_KEY forte.
Para o SIP, publique 5060/udp, 5060/tcp e a faixa WACALLS_RTP_PORT_MIN..MAX/udp em mode=host, e aponte WACALLS_PUBLIC_IP para o IP real da máquina.
Em nuvens que bloqueiam UDP de entrada, o ICE-TCP (WebRTC) e o transporte WebSocket (WACALLS_DEFAULT_TRANSPORT=auto) mantêm o áudio funcionando.
Para buildar a própria imagem: docker build -t astraonline/astracalls:develop . (o Dockerfile compila o codec a partir do submódulo opus_mlow).

🔌 API

A documentação completa (OpenAPI 3, 179 rotas) é servida pelo próprio servidor em /api-docs.html (Swagger UI) e está em client/public/openapi.yaml.

Todas as rotas são escopadas por sessão (/api/sessions/{sid}/…). Os eventos chegam por um único canal SSE (GET /api/events?clientId=…), marcados com o sessionId de origem. Se WACALLS_API_KEY estiver setada, envie X-API-Key (ou ?apiKey= no SSE/WS).

Área	Rotas (resumo)
Sessões	`GET/POST /api/sessions`, `DELETE /{sid}`, `/logout`, `/pair`, `/pair-code`, `/pair-passkey`, `/proxy`, `/recording`, `/restriction-status`
Chamadas	`POST /calls` (`{phone, video?, record?}`), `/calls/{id}/webrtc` (SDP), `GET /calls/{id}/ws` (PCM16), `/accept`, `/reject`, `DELETE /calls/{id}`, `/hold`, `/resume`, `/pickup`, `/transfer`, `/mute`, `/hand`, `/video/{request\|accept\|reject\|stop}`, `/spy` (espiar: WebRTC recvonly / `GET /spy/ws` PCM16), `/volume` (ganho 0..3), `/silence` (silenciar o toque só na tela), `POST /calls/fake`, `GET /calls`, `GET /history`
Grupo	`POST /calls/group`, `POST /calls/group/end`, `GET /calls/group/ws`, `GET /calls/group/video-ws`, `GET /calls/group/roster`
Disparos	`POST /broadcast` (ligações, áudio/vídeo), `POST /blast` + `GET /blasts`, `/blasts/{id}`, `/blasts/{id}/cancel`
Mensagens	`POST /messages/{text\|image\|audio\|video\|ptv\|document\|sticker\|contact\|location\|link-preview\|poll\|poll-vote\|event\|event-response\|pix\|product\|product-native\|interactive\|buttons\|list\|carousel\|form\|disappearing\|seen\|typing\|forward}`, `PUT /messages/{edit\|react}`, `GET /messages`, `/messages/search`, `/messages/{id}/media`, `/messages/new-message-id`, `DELETE /messages`, `/schedule`
Status / presença	`POST /status/{text\|image\|video\|audio}`, `POST /presence`, `/presence/{jid}/subscribe`
Contatos / grupos / canais	`GET /contacts`, `/contacts/check`, `/contacts/{jid}`, `/picture`, `/business`, `/block`, `/unblock`, `GET /blocklist`; `GET/POST /groups`, `/groups/{gid}/…` (participantes, convite, pedidos, configurações, foto, assunto, descrição, sair; `POST /groups/{gid}/history/share` e `shareHistory` no add: compartilhar o histórico recente com quem entrou); `GET/POST /communities`, `/communities/{cid}` (+ grupos), `/communities/{cid}/groups` (listar/criar), `/groups/link`, `/groups/unlink`, `/participants` (+ `/participants/add`); `GET /channels`, `/channels/{id}/…` (seguir, mutar, mensagens)
Chats / perfil / privacidade	`GET /chats`, `/chats/{chatId}/messages`, `PUT /chats/{chatId}/disappearing`, `PUT /disappearing`; `GET /profile`, `/profile/qr`, `PUT /profile/status`; `GET/PUT /privacy`, `GET /privacy/status`
Webhooks	`GET/POST/DELETE /webhook` (eventos, `secret` HMAC), `GET /webhooks/status`, `/webhooks/dlq`, `POST /webhooks/dlq/{id}/replay`, `/webhooks/reenable`
Chatwoot	`GET/POST/DELETE /chatwoot`, `POST /chatwoot/webhook`, `/chatwoot/import-history`, `/chatwoot/groups/{gid}/open`, `/chatwoot/channels/{id}/open`, `GET /api/chatwoot/resolve`
SIP	`GET /api/sip/status`, `GET/POST /sip` (credenciais p/ o PBX registrar aqui), `GET/POST /sip-ext` (registrar num PBX externo: host, porta, usuário, senha, ramal, proxy)
Widget / formulários	`GET /api/widget-key`, `POST /api/widget-tokens`, `GET /forms/{token}`, `POST /forms/{token}/submit` (públicas, token como capability)
Infra	`GET /api/config` (flags, versão, commit), `GET /livez`, `/readyz`, `/metrics`, `GET /recordings/{id}`

🔗 Integração com n8n

Automatize o WhatsApp no n8n sem escrever código: o node oficial n8n-nodes-astracalls já está publicado no npm, todo em português.

Instalação: no n8n, abra Configurações → Community Nodes → Install, digite n8n-nodes-astracalls e clique em Install. No Docker, use N8N_COMMUNITY_PACKAGES=n8n-nodes-astracalls.

Credencial: a URL do seu AstraCalls e a API Key (WACALLS_API_KEY).

Node	O que faz
AstraCalls	55 operações em 8 recursos: Mensagem (texto, mídia, documento, enquete, botões, lista, formulário nativo, reagir, editar, apagar…), Chamada (ligar, ligação fantasma, disparo de ligações com áudio/vídeo), Grupo, Comunidade, Contato, Sessão, Formulário e Requisição Personalizada (qualquer uma das 179 rotas)
AstraCalls Trigger	Inicia o fluxo com 15 eventos: mensagem recebida, leitura, reação, voto em enquete, formulário respondido, entrada/saída de grupo, gravação de chamada, desconexão da sessão… Configura o webhook da sessão sozinho ao ativar

Fácil de usar: a sessão é escolhida numa lista (nome + número), o destino aceita número com ou sem o 9º dígito e a mídia vem por URL ou de um arquivo de etapa anterior.
Pronto para responder: o gatilho entrega de, nome, texto e responderPara prontos para usar no envio, e ignora as mensagens da própria conta (sem loop).
Agentes de IA: o node pode ser usado como ferramenta pelos agentes de IA do n8n.

📘 Tutorial passo a passo: instalar, criar a credencial, enviar a primeira mensagem e montar um robô que responde, com fluxo pronto para importar e 10 fluxos de exemplo (menu com botões, atendente de IA, enquete, disparo de ligações…).

🤖 MCP para agentes de IA

O AstraCalls traz um servidor MCP (Model Context Protocol) embutido: Claude, ChatGPT, Cursor, VS Code, n8n e outros agentes de IA usam o WhatsApp direto, sem instalar nada.

Chaves por sessão (recomendado): no painel, botão MCP da sessão → Nova chave. A chave fica presa àquele número, pode ser somente leitura e é revogada a qualquer momento. Ela não permite parear, desconectar nem mexer em webhooks, Chatwoot, SIP ou proxy. O painel mostra, uma única vez, a URL e as configurações prontas para copiar. Pela API: GET/POST /api/sessions/{sid}/mcp-keys e DELETE /api/sessions/{sid}/mcp-keys/{id}.

Cliente	Como conectar
claude.ai, ChatGPT (conector personalizado)	URL `https://SEU-ASTRACALLS/mcp/<chave>`
Claude Code	`claude mcp add --transport http astracalls https://SEU-ASTRACALLS/mcp --header "Authorization: Bearer <chave>"`
Claude Desktop, Cursor, VS Code	`mcpServers` → `{"type":"http","url":"https://SEU-ASTRACALLS/mcp","headers":{"Authorization":"Bearer <chave>"}}`
n8n	Ferramenta MCP Client do agente de IA, endereço `/mcp` e autenticação Bearer

Acesso de administrador: https://SEU-ASTRACALLS/api/mcp com a API Key da instância (WACALLS_API_KEY) enxerga todas as sessões; o agente escolhe o número por nome, telefone ou ID.

44 ferramentas: enviar texto, mídia, documento, localização, contato, enquete, botões e lista; reagir, editar, apagar, marcar como lida e "digitando…"; ler conversas e buscar mensagens; ligar, encerrar, toque fantasma e disparo de ligações; contatos, grupos e comunidades; limite de conversas novas e restrição; e api_request para as demais rotas da sessão.

Quem tem a chave usa o número: trate-a como senha e revogue as que não usa mais.

🧪 Testes

go test ./...                 # mídia (SRTP/SRTCP, STUN, RTP, H.264, cripto de grupo), sinalização, servidor
cd client && npm run build    # type-check + build de produção do painel

🔒 Segurança

Em produção, sempre defina WACALLS_API_KEY — sem ela qualquer um com acesso HTTP pode criar contas, fazer chamadas, enviar mensagens e ler histórico.
O banco de cada sessão guarda credenciais do WhatsApp. Mantenha o Postgres protegido e fora da internet.
Exponha sempre por HTTPS (getUserMedia exige contexto seguro).
Use secret no webhook e verifique X-Webhook-Signature no consumidor.
O SIP na 5060 recebe varredura da internet o tempo todo: só sessões com credenciais válidas registram (Digest MD5); considere restringir a porta por firewall aos IPs dos PBXs.

🛠️ Suporte Profissional

Precisa de ajuda para melhorar, customizar ou implementar o projeto?

📱 WhatsApp: +55 61 9 9687-8959

💼 Temos uma equipe especializada para:

✅ Customizações e melhorias ✅ Implementação e deploy completo ✅ Configuração de arquitetura SaaS ✅ Integração com outras APIs ✅ Desenvolvimento de features específicas ✅ Suporte técnico dedicado ✅ Consultoria em automação WhatsApp ✅ Treinamento e documentação

📄 Licença

O AstraCalls é distribuído sob a licença GNU AGPL-3.0 — veja LICENSE.

Isso significa que qualquer uso em rede (inclusive SaaS) exige disponibilizar o código-fonte das modificações aos usuários do serviço.

O AstraCalls é um fork do WaCalls, que é licenciado sob MIT. Conforme exigido pela MIT, o aviso de copyright original (© 2026 jotadev66) é preservado em LICENSE.WaCalls. As porções originais permanecem sob os termos MIT; o trabalho derivado, como um todo, é licenciado sob AGPL-3.0.