---
title: "Grupos de lançamento no WhatsApp: automação com rotação de grupos pela API"
description: "Como automatizar grupos de lançamento no WhatsApp pela API não oficial: criar grupos em sequência, link único com rotação, modo anúncio e dia do carrinho."
url: "https://wame.api.br/blog/grupos-lancamento-whatsapp-automacao-api"
language: "pt-BR"
og:type: "article"
published_time: "2026-09-28"
modified_time: "2026-09-28"
author: "Raphael Serafim"
keywords: "api whatsapp não oficial, api não oficial whatsapp, gerenciar grupos whatsapp api, grupo de lançamento whatsapp, rotação de grupos whatsapp, link único grupo whatsapp, automação lançamento whatsapp"
reading_time: "9 min de leitura"
---

# Grupos de lançamento no WhatsApp: automação com rotação de grupos pela API

> Como automatizar grupos de lançamento no WhatsApp pela API não oficial: criar grupos em sequência, link único com rotação, modo anúncio e dia do carrinho.

**Um grupo de lançamento automatizado pela API não oficial do WhatsApp funciona assim: seu sistema cria os grupos em sequência, guarda o link de convite de cada um e publica um link único que sempre leva ao grupo com vaga. Durante o aquecimento os grupos ficam em modo anúncio, no dia do carrinho a conversa abre por código, e as mensagens saem em todos os grupos com espaçamento.** Nada disso exige alguém com o celular na mão às três da manhã.

Quem já fez lançamento na mão conhece o roteiro: criar grupo a grupo, copiar link, trocar o link da página quando enche, colar a mesma mensagem em vinte conversas, esquecer de fechar uma. Este guia mostra como transformar esse roteiro em código.

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

## A regra que vem antes de qualquer código

Grupo de lançamento só funciona com gente que **se inscreveu**. A pessoa deixou o e-mail na página, recebeu o link e clicou para entrar. Essa escolha é o que faz o grupo ter engajamento — e é o que mantém o número seguro.

O atalho de pegar uma lista e adicionar todo mundo direto no grupo é exatamente o comportamento que gera denúncia em massa. A WAME não apoia esse uso. Neste guia, toda entrada acontece pelo **link de convite**, e a API faz o trabalho chato em volta dele.

Para o panorama de tudo o que dá para fazer com grupos, veja [automatizar grupos de WhatsApp pela API](/blog/automatizar-grupos-whatsapp-api). Aqui o foco é o formato específico de lançamento.

## A arquitetura em quatro peças

1. **Criador de grupos:** cria os grupos da campanha, já em modo anúncio, e guarda ID e link de convite.
2. **Link único com rotação:** um endereço seu (por exemplo, `seusite.com/entrar`) que redireciona para o grupo com vaga.
3. **Agenda de mensagens:** envia a mesma comunicação em todos os grupos, um por vez.
4. **Chaves de conversa:** abre e fecha os grupos nos horários da campanha.

Tudo gira em torno de uma tabela simples: `grupos(id, nome, link, ordem, status)`.

## Criar os grupos em sequência

`POST /{key}/groups` cria o grupo e a resposta já traz duas coisas úteis: o grupo em `data` (com o `data.id`, o JID terminado em `@g.us`) e o link de convite pronto em `groupLink`.

```bash
curl -X POST "https://server.wame.api.br/SUA_KEY/groups" \
  -H "Content-Type: application/json" \
  -d '{ "name": "Lançamento Curso X #01", "participants": ["5511988887777"] }'
```

O participante inicial é o seu time (um admin de apoio, por exemplo), não um inscrito. Em código, criando os grupos da campanha com calma:

```js
const BASE = 'https://server.wame.api.br/SUA_KEY';
const esperar = (ms) => new Promise((r) => setTimeout(r, ms));

async function api(metodo, caminho, corpo) {
  const r = await fetch(`${BASE}${caminho}`, {
    method: metodo,
    headers: { 'Content-Type': 'application/json' },
    body: corpo ? JSON.stringify(corpo) : undefined,
  });
  return r.json();
}

async function criarGrupos(campanha, quantidade, apoio) {
  const grupos = [];
  for (let i = 1; i <= quantidade; i++) {
    const nome = `${campanha} #${String(i).padStart(2, '0')}`;
    const r = await api('POST', '/groups', { name: nome, participants: [apoio] });

    const id = r.data.id;
    await api('PATCH', `/groups/${id}?setting=announcement`);   // só admins falam
    await api('PUT', `/groups/${id}`, {
      name: nome,
      description: 'Grupo oficial do lançamento. Avisos por aqui; dúvidas no privado.',
    });

    grupos.push({ id, nome, link: r.groupLink, ordem: i, status: 'ativo' });
    await esperar(20000); // um grupo a cada ~20s: ninguém cria 30 grupos num segundo
  }
  return grupos; // grave no seu banco
}
```

Duas decisões importam aqui. Primeiro, **não crie todos de uma vez**: comece com alguns e crie o próximo quando o atual estiver perto de encher. Segundo, **espaçe as criações**. Um número que cria dezenas de grupos no mesmo minuto não se parece com nenhuma pessoa real.

## O link único com rotação

A página de captura mostra um link só. Ele aponta para um endpoint seu, que decide o destino na hora do clique:

```js
// GET /entrar — redireciona para o primeiro grupo com vaga
app.get('/entrar', async (req, res) => {
  const grupos = await db.grupos.ativosPorOrdem();

  for (const g of grupos) {
    const membros = await contarMembros(g.id);
    if (membros < LIMITE_POR_GRUPO) return res.redirect(302, g.link);
    await db.grupos.marcarCheio(g.id);
  }

  res.redirect(302, '/lista-de-espera'); // acabaram as vagas: avise e crie o próximo
});

async function contarMembros(id) {
  // /members devolve a lista de participantes em `data`.
  const r = await api('GET', `/groups/${id}/members`);
  return (r.data ?? []).length;
}
```

Consultar os membros a cada clique funciona em campanha pequena. Em campanha grande, **guarde a contagem em cache** por alguns segundos, ou mantenha o contador pelo webhook de participantes (veja abaixo). Assim o redirect fica instantâneo e você não consulta a API mil vezes por minuto.

O `LIMITE_POR_GRUPO` é decisão sua. O limite atual do WhatsApp por grupo já passou de mil participantes, mas lançamento costuma trabalhar bem abaixo disso, deixando folga para o time e para quem entra atrasado.

## Contador em tempo real pelo webhook

Toda entrada e saída gera um evento no webhook de grupos (configurado em `webhookGroup` via `PUT /{key}/instance`). No formato `meta`, ele chega com `field: "groups"`:

```js
app.post('/webhook/grupos', (req, res) => {
  res.sendStatus(200);
  const change = req.body?.entry?.[0]?.changes?.[0];
  if (change?.field !== 'groups') return;

  const { event, id, action, participants } = change.value.groups;
  if (event !== 'participants_updated') return;

  const delta = action === 'add' ? participants.length
              : action === 'remove' ? -participants.length : 0;
  if (delta) db.grupos.ajustarContagem(id, delta);
});
```

O `action` vem como `add`, `remove`, `promote` ou `demote`; para contar vaga, some em `add` e subtraia em `remove`. Com isso, o redirect lê o número do seu banco. A consulta a `/members` fica para uma conciliação periódica, caso algum evento se perca.

## Mensagens programadas em todos os grupos

Durante o aquecimento, você manda conteúdo: aula, lembrete, contagem regressiva. A mesma mensagem vai para todos os grupos — e é aqui que muita automação erra, disparando tudo no mesmo segundo.

```js
async function publicarEmTodos(texto) {
  const grupos = await db.grupos.ativos();
  for (const g of grupos) {
    const r = await fetch(`${BASE}/message/text`, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ to: g.id, text: texto }),
    });

    if (r.status === 429) {
      // A API pediu calma. Espere e continue de onde parou.
      await esperar(5 * 60 * 1000);
      continue;
    }
    await esperar(8000 + Math.random() * 7000); // 8 a 15s entre grupos
  }
}
```

A própria API tem freios: ela responde `429` quando o mesmo texto vai para destinos demais em pouco tempo. Não trate isso como erro a ser repetido em loop — é um sinal para desacelerar. Com espaçamento de alguns segundos entre grupos, uma campanha de dezenas de grupos termina em poucos minutos sem forçar nada.

Duas dicas de conteúdo que também ajudam o número: **varie levemente o texto** entre publicações ao longo dos dias e prefira mídia com legenda a blocos longos de texto idêntico. Para fixar o aviso principal no topo de cada grupo, veja [fixar mensagem pela API](/blog/fixar-mensagem-whatsapp-api).

## O dia do carrinho: abrir e fechar a conversa

Modo anúncio (`announcement`) deixa só admins falando. No aquecimento é o ideal: o grupo vira canal limpo. No dia da abertura, você pode liberar a conversa para gerar prova social — e fechar de novo no encerramento.

```bash
# Abrir a conversa para todos
curl -X PATCH "https://server.wame.api.br/SUA_KEY/groups/ID@g.us?setting=not_announcement"

# Fechar de novo (só admins)
curl -X PATCH "https://server.wame.api.br/SUA_KEY/groups/ID@g.us?setting=announcement"
```

Aproveite também o `locked`, que impede membros de mudar nome, foto e descrição do grupo. Em grupo grande aberto, isso evita que alguém troque o nome do grupo no meio da campanha.

Com a conversa aberta, tenha moderação pronta: grupo de lançamento é alvo de gente divulgando outro produto. O guia de [anti-link e anti-spam em grupo](/blog/moderacao-anti-link-grupo-whatsapp-bot) mostra como montar esse filtro.

## Agenda da campanha em uma tabela

Organize o lançamento como uma lista de ações com horário, e deixe um job executar:

| Quando | Ação | Endpoint |
| --- | --- | --- |
| D-10 | Criar primeiros grupos em modo anúncio | `POST /groups` + `PATCH ?setting=announcement` |
| D-10 a D-1 | Conteúdo diário em todos os grupos | `POST /message/text`, mídia |
| D-1 | Aviso fixado com data e horário | `POST /message/pin` |
| D-0, abertura | Liberar conversa | `PATCH ?setting=not_announcement` |
| D-0, abertura | Link do carrinho em todos | `POST /message/text` |
| D+3, fechamento | Fechar conversa | `PATCH ?setting=announcement` |
| D+4 | Descrição final e saída | `PUT /groups/{id}`, `DELETE /groups/{id}` |

Uma agenda assim é fácil de revisar antes da campanha e evita o clássico "esqueci de fechar o grupo 7".

## Encerrar o lançamento

Depois do fechamento, decida o destino dos grupos:

- **Reaproveitar como grupo de alunos:** troque nome e descrição com `PUT /{key}/groups/{id}` e mantenha.
- **Encerrar:** deixe em modo anúncio, atualize a descrição avisando que acabou e saia com `DELETE /{key}/groups/{id}`.

Antes de sair, guarde o que vai servir para a próxima campanha: entradas por grupo, horário de pico, taxa de saída. O guia de [métricas de grupo](/blog/metricas-grupo-whatsapp-entradas-saidas-engajamento) mostra o que medir. Se o lançamento usa muitos grupos ao longo do ano, o inventário e a limpeza em lote estão em [gerenciar centenas de grupos](/blog/gerenciar-centenas-grupos-whatsapp-api).

## Por que isso é seguro para o número

O formato acima tem baixo risco por desenho: as pessoas entram porque clicaram, o grupo é majoritariamente de avisos, as mensagens saem espaçadas e ninguém é adicionado sem pedir. A WAME cuida do resto da camada técnica — identidade de dispositivo própria por instância, envios com tempo humano, reconexão espalhada e o alerta de saúde no webhook de conexão. Para quem usa assim, a taxa de bloqueio é muito baixa.

O que derruba número em lançamento é o oposto: adicionar lista comprada, criar dezenas de grupos no mesmo minuto, disparar a mesma mensagem em todos ao mesmo tempo, insistir quando a API pede calma. Os detalhes estão em [o que realmente derruba um número](/blog/api-whatsapp-nao-oficial-bane-o-que-derruba-numero).

## Conclusão

Grupo de lançamento é um processo repetitivo com hora marcada — o tipo de trabalho que código faz melhor que gente. Com a API não oficial da WAME, você cria os grupos em sequência já em modo anúncio, publica um link único que gira para o grupo com vaga, programa o conteúdo em todos os grupos com espaçamento, abre e fecha a conversa no horário do carrinho e encerra tudo sem deixar grupo esquecido. Mantenha a entrada pelo link de convite, só para quem se inscreveu, e respeite os freios da API. Os endpoints completos estão na [documentação](/docs).

## Perguntas frequentes

### O que é rotação de grupos de lançamento no WhatsApp?

É usar um único link de entrada que sempre aponta para o grupo que ainda tem vaga. Quando um grupo enche, o link passa a levar para o próximo. Pela API, seu sistema cria os grupos, guarda o link de convite de cada um e decide para qual redirecionar consultando a quantidade de membros.

### Posso adicionar os inscritos direto no grupo pela API?

Não é o recomendado. Adicionar pessoas que não pediram para entrar gera denúncia e é um dos comportamentos que mais derrubam número. O caminho seguro é o link de convite: a pessoa se inscreve, clica e entra por vontade própria.

### Como mando a mesma mensagem em todos os grupos do lançamento?

Envie para cada grupo com to igual ao ID terminado em @g.us, um de cada vez, com alguns segundos entre os envios. Disparar tudo no mesmo segundo parece automação e pode esbarrar nos freios da própria API, que responde 429 quando detecta o mesmo texto indo para muitos destinos.

### Como abrir a conversa no grupo só no dia do carrinho?

Deixe os grupos em modo anúncio (PATCH /{key}/groups/{id}?setting=announcement) durante o aquecimento e troque para not_announcement no horário de abertura. No encerramento, volte para announcement. Tudo pode ser agendado no seu sistema.

### O que fazer com os grupos depois do lançamento?

Feche a conversa, atualize a descrição avisando que o lançamento terminou e, se não for reaproveitar, saia dos grupos com DELETE /{key}/groups/{id}. Guarde antes o que precisar de métricas e da lista de membros para a próxima campanha, respeitando quem pediu para sair.
