---
title: "Métricas de grupo no WhatsApp: entradas, saídas e engajamento pela API"
description: "Como medir entradas, saídas, churn e engajamento de grupos de WhatsApp com a API não oficial: eventos de participantes, mensagens por membro e painel SQL."
url: "https://wame.api.br/blog/metricas-grupo-whatsapp-entradas-saidas-engajamento"
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, métricas grupo whatsapp, quem saiu do grupo whatsapp, engajamento grupo whatsapp, relatório grupo whatsapp"
reading_time: "8 min de leitura"
---

# Métricas de grupo no WhatsApp: entradas, saídas e engajamento pela API

> Como medir entradas, saídas, churn e engajamento de grupos de WhatsApp com a API não oficial: eventos de participantes, mensagens por membro e painel SQL.

**Para medir um grupo de WhatsApp pela API não oficial, registre dois tipos de evento que chegam no webhook: `participants_updated` (entradas, saídas, promoções) e cada mensagem de grupo, que traz `group_id` e `from`. Com essas duas tabelas você calcula crescimento, churn, membros ativos, membros silenciosos e o efeito de cada mensagem enviada.** O WhatsApp não tem painel de grupo; você monta o seu com algumas consultas SQL.

Quem administra grupos no celular vive de impressão: "acho que o grupo esfriou", "parece que saiu gente depois daquele aviso". Com dados, essas perguntas têm resposta. Este guia mostra o que coletar, como guardar e quais métricas valem acompanhar.

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

## O que dá para medir

| Métrica | Pergunta que responde | Fonte |
| --- | --- | --- |
| Entradas por dia | O convite está funcionando? | evento de participantes |
| Saídas por dia | Algo está afastando gente? | evento de participantes |
| Churn do período | Quanto do grupo perdi? | eventos + membros |
| Mensagens por dia | O grupo está vivo? | mensagens de grupo |
| Membros ativos | Quantos falam de verdade? | mensagens de grupo |
| Membros silenciosos | Quem só observa? | membros − ativos |
| Saídas após envio | Aquela mensagem incomodou? | eventos + seus envios |

Nenhuma dessas métricas depende de ler o conteúdo das conversas. Contagem basta.

## Ligando a coleta

Aponte o webhook de grupos para o seu servidor com `PUT /{key}/instance`, no formato `meta`:

```bash
curl -X PUT "https://server.wame.api.br/SUA_KEY/instance" \
  -H "Content-Type: application/json" \
  -d '{
    "allowWebhook": true,
    "allowNumber": "all",
    "webhookGroup": "https://seu-servidor.com/webhook/grupos",
    "webhookFormat": "meta"
  }'
```

A partir daqui, entradas, saídas e mensagens de grupo chegam nessa URL. O histórico começa hoje: o que aconteceu antes da coleta não volta.

## Tabela 1: eventos de participantes

No formato `meta`, a mudança de participantes chega com `field: "groups"`:

```json
{
  "object": "wame",
  "provider": "whatsapp",
  "entry": [{
    "changes": [{
      "field": "groups",
      "value": {
        "groups": {
          "event": "participants_updated",
          "id": "120363000000000000@g.us",
          "action": "add",
          "participants": ["5511988887777@s.whatsapp.net"]
        }
      }
    }]
  }]
}
```

Grave uma linha por participante:

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

  if (change?.field === 'groups') {
    const { event, id, action, participants } = change.value.groups;
    if (event !== 'participants_updated') return;
    for (const p of participants ?? []) {
      await db.query(
        'INSERT INTO grupo_eventos (grupo, participante, acao, quando) VALUES ($1, $2, $3, now())',
        [id, p, action],
      );
    }
    return;
  }

  const msg = change?.value?.messages?.[0];
  if (msg?.group_id && !msg.from_me) {
    await db.query(
      'INSERT INTO grupo_mensagens (grupo, autor, tipo, quando) VALUES ($1, $2, $3, now())',
      [msg.group_id, msg.from, msg.type],
    );
  }
});
```

O `action` chega como `add` (entrada), `remove` (saída), `promote` (virou admin) ou `demote` (deixou de ser admin); guarde o valor como chegou e interprete nas consultas. Participantes podem aparecer como LID (`@lid`) — para contagem não faz diferença, e se precisar do telefone veja [LID no WhatsApp](/blog/lid-whatsapp-o-que-e-resolver-numero-api).

## Tabela 2: mensagens de grupo

O mesmo webhook já salva a segunda tabela no código acima: `grupo`, `autor`, `tipo` e horário. Repare que **não guardamos o texto**. Para métricas de engajamento, quem falou e quando é suficiente, e não guardar conteúdo reduz muito o problema de dado pessoal.

Um detalhe: ignore `from_me`. As mensagens da própria instância (avisos, bot) inflariam o engajamento com a sua própria voz.

## Tabela 3: fotografia de membros

Eventos contam mudanças; para saber o total, tire uma foto diária com `GET /{key}/groups/{id}/members`:

```js
async function fotografar(grupos) {
  for (const g of grupos) {
    const r = await fetch(`https://server.wame.api.br/SUA_KEY/groups/${g}/members`).then((x) => x.json());
    // /members devolve a lista de participantes em `data`.
    const membros = r.data ?? [];
    await db.query(
      'INSERT INTO grupo_membros_dia (grupo, dia, total) VALUES ($1, current_date, $2) ON CONFLICT DO NOTHING',
      [g, membros.length],
    );
    await new Promise((ok) => setTimeout(ok, 3000));
  }
}
```

A foto diária também corrige o que o webhook eventualmente perder. Se você gerencia muitos grupos, integre isso ao inventário descrito em [gerenciar centenas de grupos](/blog/gerenciar-centenas-grupos-whatsapp-api).

## As consultas que viram painel

Entradas e saídas por dia, por grupo:

```sql
SELECT grupo, date(quando) AS dia,
       count(*) FILTER (WHERE acao = 'add')    AS entradas,
       count(*) FILTER (WHERE acao = 'remove') AS saidas
FROM grupo_eventos
GROUP BY grupo, dia
ORDER BY dia DESC;
```

Churn dos últimos 30 dias:

```sql
SELECT e.grupo,
       count(*) FILTER (WHERE e.acao = 'remove')::float
         / nullif(max(m.total), 0) AS churn_30d
FROM grupo_eventos e
JOIN grupo_membros_dia m ON m.grupo = e.grupo AND m.dia = current_date
WHERE e.quando > now() - interval '30 days'
GROUP BY e.grupo;
```

Membros ativos e silenciosos na semana:

```sql
SELECT m.grupo,
       m.total AS membros,
       count(DISTINCT g.autor) AS ativos,
       m.total - count(DISTINCT g.autor) AS silenciosos
FROM grupo_membros_dia m
LEFT JOIN grupo_mensagens g
  ON g.grupo = m.grupo AND g.quando > now() - interval '7 days'
WHERE m.dia = current_date
GROUP BY m.grupo, m.total;
```

Com essas três consultas num Metabase, Grafana ou planilha, você já tem mais visibilidade que a maioria dos administradores de grupo.

## A métrica mais útil: saídas depois de um envio

Guarde também os envios que você faz para cada grupo (horário e tipo de conteúdo). Cruzando com as saídas das duas horas seguintes, você descobre qual conteúdo afasta gente:

```sql
SELECT s.id AS envio, s.tipo, s.quando,
       count(e.*) AS saidas_2h
FROM seus_envios s
LEFT JOIN grupo_eventos e
  ON e.grupo = s.grupo AND e.acao = 'remove'
 AND e.quando BETWEEN s.quando AND s.quando + interval '2 hours'
GROUP BY s.id, s.tipo, s.quando
ORDER BY saidas_2h DESC;
```

Se a promoção das 22h derruba dez pessoas e o conteúdo das 10h não derruba nenhuma, a decisão está tomada. Saída em massa também é um sinal de risco para o número: gente que sai incomodada tende a denunciar. Os outros sinais estão em [sinais de que o número está em risco](/blog/sinais-numero-whatsapp-risco-bloqueio).

## Privacidade: agregue antes de mostrar

Métricas de grupo tocam em dado pessoal de todo mundo que participa. Três regras práticas:

- **Não guarde conteúdo** se o objetivo é métrica. Autor, tipo e horário bastam.
- **Mostre agregado.** O painel exibe totais e taxas; o detalhe por pessoa fica restrito aos administradores.
- **Defina retenção.** Eventos de meses atrás raramente mudam decisão. Apague ou agregue depois de um prazo.

Nunca publique ranking de "quem mais fala" no próprio grupo sem as pessoas saberem e concordarem. Para o lado contratual, veja [API de WhatsApp e LGPD](/blog/whatsapp-api-lgpd-contrato-cliente).

## Onde as métricas mudam a operação

Com números, as decisões de grupo ficam objetivas:

- **Grupo de lançamento:** entradas por hora mostram quando a página converte e quando abrir o próximo grupo. Veja [grupos de lançamento com rotação](/blog/grupos-lancamento-whatsapp-automacao-api).
- **Grupo de clientes:** churn crescendo indica frequência alta demais de avisos.
- **Comunidade aberta:** poucos ativos e muitos silenciosos pedem conteúdo que convide à conversa — uma [enquete](/blog/pesquisa-satisfacao-enquete-whatsapp-api), por exemplo.

## Conclusão

Métricas de grupo no WhatsApp saem de dois eventos que a API não oficial da WAME entrega no webhook de grupos — `participants_updated` e as mensagens com `group_id` — mais uma fotografia diária de membros. Com três tabelas e algumas consultas SQL, você mede entradas, saídas, churn, membros ativos e o efeito de cada envio, sem guardar o conteúdo das conversas. É o painel que o WhatsApp não tem, e é ele que transforma a administração de grupo de palpite em decisão. Os formatos completos estão na [documentação](/docs).

## Perguntas frequentes

### Como saber quem entrou e saiu de um grupo de WhatsApp pela API?

Configure o webhook de grupos (webhookGroup em PUT /{key}/instance). Cada entrada, saída, promoção ou rebaixamento chega como evento com field groups e value.groups contendo event participants_updated, o id do grupo, a action e a lista de participants. Grave cada evento numa tabela e você tem o histórico completo.

### Dá para medir engajamento de um grupo?

Sim. Toda mensagem de grupo chega no webhook com group_id e from (quem enviou). Contando mensagens por grupo, por dia e por membro, você calcula membros ativos, membros silenciosos e picos de conversa.

### O que é churn de grupo no WhatsApp?

É a proporção de pessoas que saíram do grupo num período em relação ao total de membros. Churn alto logo depois de uma mensagem específica é o melhor indicador de que aquele conteúdo, horário ou frequência incomodou.

### Consigo ver as métricas de grupos antigos, de antes da integração?

Os eventos de entrada, saída e mensagens só são registrados a partir do momento em que o seu webhook começa a recebê-los. Para o estado atual (membros e admins), use GET /{key}/groups/{id}/members a qualquer momento; o histórico começa no dia em que você ligar a coleta.

### Posso mostrar quem mais fala no grupo para os membros?

Evite. Métricas de grupo envolvem dado pessoal de quem participa. Use os números agregados para tomar decisões (horário, frequência, conteúdo) e mantenha o detalhe por pessoa restrito aos administradores, pelo tempo necessário.
