Skip to main content

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.

Go React whatsmeow pion PostgreSQL Docker n8n License

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.

No comments to display