# API de Instagram e Messenger na mesma API do WhatsApp: uma instância, um padrão

> API de Instagram Direct e Messenger oficiais na mesma API do WhatsApp: uma instância, um padrão Meta, o campo provider escolhe o canal. Sem criar app na Meta.

**Você não precisa manter três integrações para atender no WhatsApp, no Instagram Direct e no Messenger.** Na WAME, os três canais oficiais vivem na **mesma instância** e falam o **mesmo padrão** (o envelope da Meta). Para trocar de canal, você muda um único campo: `provider`. Nada de criar app na Meta, montar três webhooks ou aprender três SDKs.

Se o seu time já usa a API de WhatsApp e agora precisa responder também no Direct e no Messenger, este artigo mostra por que isso pode ser uma extensão do que você já tem — e não um projeto novo do zero.

## O problema: 3 canais quase sempre viram 3 integrações

Quando você decide atender oficialmente no Instagram Direct e no Messenger, o caminho tradicional é doloroso:

- **Três apps (ou permissões) diferentes** no Meta for Developers, cada um com seu processo de revisão.
- **Três fluxos de autenticação e token**, com System User, permissões e renovação manual para cada produto.
- **Três formatos de payload** para aprender — o corpo de envio e o webhook do Instagram não são iguais aos do Messenger, que por sua vez diferem do WhatsApp.
- **Três webhooks** para configurar, validar (verify token, assinatura HMAC) e manter no ar.

Na prática, cada canal novo é um mini-projeto: mais código, mais pontos de falha, mais superfície para manter. E, quando a Meta muda algo, você atualiza em três lugares. É aí que a maioria dos times desiste do multicanal — ou entrega uma integração frágil.

## A solução WAME: 1 instância, 1 padrão

A WAME é **Meta Business Partner** (parceira oficial desde 2017, com mais de 50 mil instâncias ativas). Isso muda o ponto de partida: a infraestrutura oficial já existe e é mantida pela WAME. Você **não** precisa:

- ❌ Criar um app no **Meta for Developers**.
- ❌ Virar **Tech Provider** (Solution Partner) para operar os canais.
- ❌ Montar webhook por produto, gerar e renovar token na mão.

Em vez disso, você conecta suas contas pelo **Embedded Signup** oficial da Meta — o mesmo fluxo seguro (OAuth + token criptografado) que já usa para o WhatsApp — e passa a ter WhatsApp, Instagram Direct e Messenger **na mesma instância**. Um único padrão de envio e de recebimento, no formato Meta, para os três.

Quer entender a credencial por trás disso? Veja [WAME é parceira oficial da Meta](/blog/wame-parceira-oficial-meta). Para a visão geral do multicanal, temos a página [API oficial de Instagram e Messenger](/api-oficial-instagram-messenger).

> A ideia central: você aprende **um** padrão e ganha **três** canais. O `provider` é o que decide para onde a mensagem vai.

## Enviar nos 3 canais: mesmo método, só muda o `provider`

O envio é idêntico nos três canais. O `provider` é `whatsapp` por padrão; para Instagram Direct você usa `instagram` e para Messenger, `messenger`. Isso vale para os tipos suportados: `text`, `template`, `button`, `audio`, `image`, `video` e `document`.

Com o SDK Node/TypeScript (`npm i @raphaelvserafim/client-api-whatsapp`):

```ts
import { Wame, TypeMessage } from '@raphaelvserafim/client-api-whatsapp';

const wa = new Wame({ server: "https://us.api-wa.me", key: "YOUR_KEY" });

// WhatsApp (padrão)
await wa.message.send({ type: TypeMessage.TEXT, body: { to: "5511999999999", text: "Oi pelo WhatsApp" } });

// Instagram — mesmo método, só o provider
await wa.message.send({ type: TypeMessage.TEXT, body: { to: "IG_USER_ID", text: "Oi pelo Instagram", provider: "instagram" } });

// Messenger
await wa.message.send({ type: TypeMessage.TEXT, body: { to: "PSID", text: "Oi pelo Messenger", provider: "messenger" } });
```

A classe é `Wame` (`WhatsApp` é um alias depreciado). Se o seu fluxo é majoritariamente Instagram, dá para fixar o canal no client: `new Wame({ server, key, provider: "instagram" })`. A referência completa do SDK TypeScript está em [/docs/sdk/ts](/docs/sdk/ts).

Com PHP (`composer require raphaelvserafim/client-php-api-wa-me`):

```php
use Api\Wame\Wame;
use Api\Wame\Provider;

$wa = new Wame(['server' => 'https://us.api-wa.me', 'key' => 'YOUR_KEY']);

$wa->message->sendText('5511999999999', 'Oi pelo WhatsApp');
$wa->message->sendText('IG_USER_ID', 'Oi pelo Instagram', Provider::INSTAGRAM);
$wa->message->sendText('PSID', 'Oi pelo Messenger', Provider::MESSENGER);
```

E, se você prefere HTTP puro, é o mesmo endpoint com o `provider` no corpo:

```bash
curl -X POST "https://us.api-wa.me/YOUR_KEY/message/text" \
  -H "Content-Type: application/json" \
  -d '{"to":"5511999999999","text":"Olá!","provider":"instagram"}'
```

A `key` da instância vai no path e a base é `https://us.api-wa.me`. Repare no destinatário: no WhatsApp é o telefone; no Instagram é o `IG_USER_ID`; no Messenger é o `PSID`. O resto do contrato é o mesmo.

## Receber nos 3 canais: mesmo envelope de webhook

O recebimento segue a mesma lógica. Você configura o webhook uma vez, com um `PUT` na instância, e passa a receber os três canais no **formato Meta**:

```bash
curl -X PUT "https://us.api-wa.me/YOUR_KEY/instance" \
  -H "Content-Type: application/json" \
  -d '{"allowWebhook":true,"webhookFormat":"meta","webhookMessage":"https://seu-servidor/webhook"}'
```

A partir daí, todas as mensagens chegam no **mesmo envelope**. O campo de topo `provider` diz de qual canal veio — então um único handler resolve os três:

```json
{
  "object": "wame",
  "provider": "instagram",
  "instance": "YOUR_INSTANCE_ID",
  "official": true,
  "entry": [{ "id": "...", "changes": [{ "field": "messages", "value": {
    "messaging_product": "whatsapp",
    "metadata": { "display_phone_number": "5511999990000", "phone_number_id": "YOUR_INSTANCE_ID" },
    "contacts": [{ "profile": { "name": "Fulano" }, "wa_id": "5511988887777" }],
    "messages": [{ "from": "5511988887777", "id": "wamid.XXX", "timestamp": "1700000000", "type": "text", "text": { "body": "Olá!" } }]
  }}]}]
}
```

Para uma mensagem do Messenger, o mesmo JSON chega com `"provider": "messenger"`; para o WhatsApp, com `"provider": "whatsapp"`. A estrutura interna (`entry`, `changes`, `messages`) é a que você já conhece da Cloud API — por isso, se seu backend já processa webhooks de WhatsApp, ele já entende Instagram e Messenger com pouquíssima adaptação. Os detalhes e os tipos de evento estão em [/docs/webhooks](/docs/webhooks).

> O `provider` no topo é a única ramificação que o seu código precisa. Roteie por ele e pronto: um envelope, três canais.

## Quando recomendar essa abordagem

Uma instância com um padrão faz sentido especialmente quando:

- **Você já usa a API de WhatsApp da WAME** e quer adicionar Instagram Direct e Messenger sem reescrever a integração.
- **Seu atendimento é omnichannel**: o cliente inicia no Direct, migra para o WhatsApp, volta pelo Messenger — e você quer tudo no mesmo backend, com histórico coerente.
- **Você constrói para clientes** (agência, SaaS, chatbot) e não quer manter três integrações por conta, nem virar Tech Provider.
- **Você quer reduzir manutenção**: um formato, um webhook, um SDK — menos código para quebrar quando a Meta atualiza algo.

Quando **não** compensa? Se o seu produto vive de um canal só e não há intenção de multicanal no curto prazo, você pode começar apenas pelo WhatsApp — e habilitar os outros canais depois, sem trocar de arquitetura, já que o padrão é o mesmo.

Vale lembrar que a WAME oferece **oficial (Cloud API)** e **não oficial (QR Code)** na mesma plataforma. Para os canais da Meta com o padrão descrito aqui — Instagram Direct e Messenger oficiais — o caminho é a conexão oficial via Embedded Signup.

## Comece agora

Se você chegou até aqui, a mensagem é simples: **não construa três integrações.** Conecte suas contas de Instagram e Messenger à mesma instância de WhatsApp que você já domina, envie mudando só o `provider` e receba tudo no mesmo envelope. Com 99,9% de uptime, suporte 24/7 em português e planos a partir de R$28,99/mês, dá para colocar os três canais no ar hoje.

Crie sua instância e conecte os canais no [portal da WAME](https://portal.api-wa.me/). Depois, use a [referência do SDK TypeScript](/docs/sdk/ts) e a [documentação de webhooks](/docs/webhooks) para plugar no seu backend — e a página [API oficial de Instagram e Messenger](/api-oficial-instagram-messenger) para os detalhes de cada canal.

Um padrão. Uma instância. Três canais oficiais da Meta.

## Perguntas frequentes

### Preciso criar um app no Meta for Developers para usar a API de Instagram e Messenger?

Não. A WAME é Meta Business Partner e mantém o app aprovado, o webhook central e a renovação de token. Você conecta suas contas pelo fluxo oficial Embedded Signup e usa Instagram Direct, Messenger e WhatsApp na mesma instância, sem virar Tech Provider.

### Como escolho entre WhatsApp, Instagram e Messenger no envio?

É o mesmo método de envio nos três canais. Você só muda o campo provider no corpo da requisição: whatsapp (padrão), instagram ou messenger. Não há endpoints diferentes nem SDKs separados para cada canal.

### O webhook de recebimento é diferente para cada canal?

Não. Os três canais chegam no mesmo envelope de webhook no formato Meta. O campo provider indica de qual canal veio a mensagem (instagram, messenger ou whatsapp), então você trata tudo com um único handler.

### As APIs de Instagram e Messenger são oficiais?

Sim. A conexão usa a infraestrutura oficial da Meta via Embedded Signup, com OAuth e token criptografado. Você é dono das contas, vê os canais conectados e pode revogar o acesso quando quiser.

### Quanto custa usar os três canais na WAME?

Os planos começam a partir de R$28,99/mês. Você usa WhatsApp, Instagram Direct e Messenger na mesma instância e no mesmo padrão, com suporte 24/7 em português e 99,9% de uptime.