Gerenciando grupos do WhatsApp

Tudo o que a página Groups faz, doze operações em /v1/whatsapp/groups também fazem, então toda a vida de um grupo cabe em código: criá-lo, aguardar WhatsApp confirmar, distribuir o link de convite, decidir quem entra, manter os detalhes e as fixações atualizados, e excluí-lo quando a conversa terminar.

Duas coisas definem cada chamada nesta página. Ninguém pode ser adicionado a um grupo, então o link de convite é a única forma de entrar, e convidar pessoas acontece fora da API. A maioria das alterações se consolida em WhatsApp e não na resposta, então a chamada que aceita uma alteração não é a que informa que ela funcionou; Como uma alteração se consolida cobre isso uma vez para cada operação à qual se aplica.

Grupos do WhatsApp cobre para que serve um grupo e o mesmo ciclo de vida no dashboard. Enviando para um grupo do WhatsApp cobre o envio de mensagens para um grupo.

Pré-requisitos

Você precisa de uma chave API com acesso a whatsapp_management: nível de leitura para as leituras nesta página, nível de escrita para todo o resto. Usuários, equipes e funções cobre como conceder esse acesso.

Você também precisa de um número comercial com status de Official Business Account, que WhatsApp exige do administrador de um grupo e que Antes de criar um grupo cobre como obter. GET /v1/whatsapp/numbers informa isso por número como is_official_business_account, então leia lá em vez de descobrir a partir de um 412. O flag corresponde ao meta_synced_at do número, então um número conectado há poucos minutos pode ainda não ter sido lido de volta.

Inicialize o client para sua linguagem usando o guia de SDK para TypeScript, Python, Go ou PHP. Para exemplos com CLI, instale e autentique o CLI. Os exemplos com cURL usam o host dos EUA; se sua chave começa com bk_eu1_, chame https://eu1.platform.bird.com em vez disso. Os SDKs leem a região a partir da sua chave, então não definem host.

1. Criar o grupo

Uma criação nomeia o número administrador e um assunto, e mais ninguém. Duas escolhas são fixas por toda a vida do grupo e não podem ser alteradas depois: o número, e join_approval_mode, que decide se abrir o link de convite admite alguém diretamente (auto_approve, o padrão) ou gera uma solicitação que você decide (approval_required).

Note: creating a group needs a business number with Official Business Account status, the blue check mark WhatsApp puts next to a business name in the chat. WhatsApp Official Business Account covers what Meta requires and how to request it.

const group = await bird.whatsapp.groups.create({
  whatsapp_number_id: "wan_01krdgeqcxet5s7t44vh8rt9mg",
  subject: "Norwood Fleet — Tuesday route",
  join_approval_mode: "approval_required",
});
console.log(group.id, group.status); // pending; read it back for the invite link

group = client.whatsapp.groups.create(
    whatsapp_number_id="wan_01krdgeqcxet5s7t44vh8rt9mg",
    subject="Norwood Fleet — Tuesday route",
    join_approval_mode="approval_required",
)
print(group.id, group.status)  # pending; read it back for the invite link

group, err := client.Whatsapp.Groups.Create(context.Background(), bird.WhatsappGroupsCreateParams{
	WhatsappNumberID: "wan_01krdgeqcxet5s7t44vh8rt9mg",
	Subject:          "Norwood Fleet — Tuesday route",
	JoinApprovalMode: bird.Ptr(bird.WhatsAppGroupJoinApprovalMode("approval_required")),
})
if err != nil {
	log.Fatal(err)
}
fmt.Println(*group.Id, *group.Status) // pending; read it back for the invite link

$group = $bird->whatsapp->groups->create(
    (new WhatsAppGroupCreate())
        ->setWhatsappNumberId('wan_01krdgeqcxet5s7t44vh8rt9mg')
        ->setSubject('Norwood Fleet — Tuesday route')
        ->setJoinApprovalMode('approval_required'),
);
echo $group->getId(), ' ', $group->getStatus(); // pending

bird whatsapp groups create \
  --whatsapp-number-id wan_01krdgeqcxet5s7t44vh8rt9mg \
  --subject 'Norwood Fleet — Tuesday route' \
  --join-approval-mode approval_required

curl -X POST "https://us1.platform.bird.com/v1/whatsapp/groups" \
  -H "Authorization: Bearer $BIRD_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
      "whatsapp_number_id": "wan_01krdgeqcxet5s7t44vh8rt9mg",
      "subject": "Norwood Fleet — Tuesday route",
      "join_approval_mode": "approval_required"
    }'

O API retorna 202 com o grupo em status pending e sem invite_link: WhatsApp emite o link quando confirma o grupo. O assunto aceita até 128 caracteres e uma description opcional até 2.048, e ambos são exibidos a qualquer pessoa que abrir o link, então nomeie o grupo pelo seu propósito e não por uma referência interna.

2. Aguardar WhatsApp confirmar

Leia o grupo de volta até que seu status saia de pending. A leitura responde 200 independentemente do status, então ramifique com base em status em vez de no sucesso da chamada.

const group = await bird.whatsapp.groups.get("wag_01krdgeqcxet5s7t44vh8rt9mg");
console.log(group.status, group.invite_link);

group = client.whatsapp.groups.get("wag_01krdgeqcxet5s7t44vh8rt9mg")
print(group.status, group.invite_link)

group, err := client.Whatsapp.Groups.Get(context.Background(), "wag_01krdgeqcxet5s7t44vh8rt9mg")
if err != nil {
	log.Fatal(err)
}
fmt.Println(*group.Status)
if group.InviteLink != nil {
	fmt.Println(*group.InviteLink)
}

$group = $bird->whatsapp->groups->get('wag_01krdgeqcxet5s7t44vh8rt9mg');
echo $group->getStatus(), ' ', $group->getInviteLink();

bird whatsapp groups get wag_01krdgeqcxet5s7t44vh8rt9mg

curl "https://us1.platform.bird.com/v1/whatsapp/groups/wag_01krdgeqcxet5s7t44vh8rt9mg" \
  -H "Authorization: Bearer $BIRD_API_KEY"

Cinco status podem retornar, e apenas um deles é um grupo com o qual você pode trabalhar:

failed é a outra saída de pending, e last_operation.last_error.description traz o motivo do próprio WhatsApp. Nunca tente novamente uma criação que falhou nesse grupo: crie um novo, alterando o que a recusa objetou.

3. Permitir a entrada de pessoas no grupo

Envie o invite_link do grupo às pessoas que você quer nele, pelo canal que já as alcança. Nenhuma operação adiciona um participante, então o link é a única forma de entrar e a decisão de participar é deles. Ele admite qualquer pessoa que o possua, então trate-o como a credencial que é: grupos WhatsApp explica até onde distribuir um.

Em um grupo auto_approve, qualquer pessoa com o link entra e não há nada a decidir. Em um grupo approval_required, abrir o link gera uma solicitação de entrada. Liste as pendentes e decida-as em lotes de até 50:

const waiting = [];
for await (const request of bird.whatsapp.groups.joinRequests.list(
  "wag_01krdgeqcxet5s7t44vh8rt9mg",
)) {
  waiting.push(request.id);
}
const result = await bird.whatsapp.groups.joinRequests.approve("wag_01krdgeqcxet5s7t44vh8rt9mg", {
  join_request_ids: waiting.slice(0, 50),
});
console.log(result.decided.length, result.failed.length);

waiting = [r.id for r in client.whatsapp.groups.join_requests.list("wag_01krdgeqcxet5s7t44vh8rt9mg")]
result = client.whatsapp.groups.join_requests.approve(
    "wag_01krdgeqcxet5s7t44vh8rt9mg",
    join_request_ids=waiting[:50],
)
print(len(result.decided), len(result.failed))

result, err := client.Whatsapp.Groups.JoinRequests.Approve(context.Background(), "wag_01krdgeqcxet5s7t44vh8rt9mg", bird.WhatsappGroupsJoinRequestsApproveParams{
	JoinRequestIDs: []string{"wgj_01krdgeqcxet5s7t44vh8rt9mg"},
})
if err != nil {
	log.Fatal(err)
}
for _, failure := range *result.Failed {
	fmt.Println(*failure.JoinRequestId, *failure.Error.Description)
}

$result = $bird->whatsapp->groups->joinRequests->approve(
    'wag_01krdgeqcxet5s7t44vh8rt9mg',
    (new WhatsAppGroupJoinRequestDecision())->setJoinRequestIds(['wgj_01krdgeqcxet5s7t44vh8rt9mg']),
);
echo count($result->getDecided() ?? []), ' ', count($result->getFailed() ?? []);

bird whatsapp groups join-requests list wag_01krdgeqcxet5s7t44vh8rt9mg
bird whatsapp groups join-requests approve wag_01krdgeqcxet5s7t44vh8rt9mg \
  --join-request-ids wgj_01krdgeqcxet5s7t44vh8rt9mg

curl -X POST "https://us1.platform.bird.com/v1/whatsapp/groups/wag_01krdgeqcxet5s7t44vh8rt9mg/join-requests/batch-approve" \
  -H "Authorization: Bearer $BIRD_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"join_request_ids": ["wgj_01krdgeqcxet5s7t44vh8rt9mg"]}'

WhatsApp decide cada solicitação individualmente, então um lote pode ser parcialmente aplicado: a resposta separa decided de failed, e cada falha traz o motivo que WhatsApp informou em error.description. Leia a resposta em vez do código de status. Uma recusa geralmente é de uma pessoa que não aceitou os termos atuais de WhatsApp, o que nenhuma nova tentativa resolve.

Aprovar mais pessoas do que o grupo comporta não recusa a chamada: as solicitações que cabem são decididas e o restante retorna em failed, cada uma dizendo que a aprovação levaria o grupo além do seu limite de participantes. A rejeição funciona da mesma forma, via POST /v1/whatsapp/groups/{group_id}/join-requests/batch-reject. Uma solicitação também sai da lista quando a própria pessoa a cancela, então um ID que era válido instantes atrás pode retornar um 422 E15051 quando você for usá-lo.

O 50 é o limite do próprio Bird por solicitação, não um limite de WhatsApp, então uma varredura de rejeição não está restrita a quantas pessoas o grupo comporta.

Acompanhe as solicitações conforme chegam

Inscreva-se em whatsapp.group.join_request_created e whatsapp.group.join_request_revoked para saber quando alguém pede para entrar e quando cancela, em vez de consultar a lista periodicamente. Uma solicitação criada e cancelada entre duas leituras da lista não deixa rastro, então esses eventos são a única forma de vê-la. Cada evento traz o join_request.id que as operações em lote recebem, então você pode decidir diretamente a partir dele. Webhooks de grupo WhatsApp traz os dois payloads e todos os campos.

Rotação do link de convite

A rotação emite um novo link e invalida todos os links anteriores do grupo, então quem ainda tiver um não consegue entrar. Faça a rotação quando um link se espalhou mais do que você pretendia ou depois de remover alguém que você não quer de volta. O novo link vem na própria chamada, que responde 200:

const link = await bird.whatsapp.groups.inviteLink.rotate("wag_01krdgeqcxet5s7t44vh8rt9mg");
console.log(link.invite_link); // every earlier link has stopped working

link = client.whatsapp.groups.invite_link.rotate("wag_01krdgeqcxet5s7t44vh8rt9mg")
print(link.invite_link)  # every earlier link has stopped working

link, err := client.Whatsapp.Groups.InviteLink.Rotate(context.Background(), "wag_01krdgeqcxet5s7t44vh8rt9mg")
if err != nil {
	log.Fatal(err)
}
fmt.Println(*link.InviteLink) // every earlier link has stopped working

$link = $bird->whatsapp->groups->inviteLink->rotate('wag_01krdgeqcxet5s7t44vh8rt9mg');
echo $link->getInviteLink(); // every earlier link has stopped working

bird whatsapp groups invite-link rotate wag_01krdgeqcxet5s7t44vh8rt9mg --yes

curl -X POST "https://us1.platform.bird.com/v1/whatsapp/groups/wag_01krdgeqcxet5s7t44vh8rt9mg/invite-link/rotate" \
  -H "Authorization: Bearer $BIRD_API_KEY"

A rotação não é como você lê o link atual. O grupo carrega seu invite_link, então ler o grupo é a leitura.

O CLI nunca solicita confirmação, então seus comandos destrutivos recebem --yes: rotacionar um link, remover um participante, excluir um grupo, desafixar uma mensagem e rejeitar solicitações de entrada são todos recusados com confirmation_required sem ele.

Como uma alteração é confirmada

WhatsApp confirma algumas alterações na própria resposta e outras em um webhook, e o código de status indica qual dos dois casos você está vendo:

Nas duas primeiras linhas, o 202 é a solicitação aceita, não aplicada. last_operation.status fica como pending até WhatsApp responder, normalmente em segundos, e então se define como success ou failed, com last_error.description trazendo o motivo em caso de falha. Releia o grupo para ver o que entrou em vigor.

Enquanto uma operação está pending, outra alteração na mesma coisa retorna um 409 E15054. Alterações no nível do grupo compartilham o last_operation do grupo, então uma renomeação pendente bloqueia uma exclusão. Cada participante carrega o seu próprio, então remover várias pessoas ao mesmo tempo dá a cada uma seu próprio estado e sua própria falha, e apenas a remoção pendente daquela pessoa bloqueia outra tentativa nela.

Dois 409s protegem as escritas e status é verificado primeiro, então um grupo que não está active retorna E15047 independentemente do que last_operation diga. Isso importa para um grupo ainda sendo criado, que está pendente nas duas condições ao mesmo tempo.

Toda escrita também recebe um header Idempotency-Key. Idempotência cobre como tentar novamente com segurança.

Alterar o assunto, a descrição ou a foto do grupo

Uma atualização altera o que os participantes veem no topo do grupo. Campos que você omitir são mantidos como estão; envie null para limpar a descrição ou a foto, já que uma string vazia é um 422 em vez de uma segunda forma de limpar.

const group = await bird.whatsapp.groups.update("wag_01krdgeqcxet5s7t44vh8rt9mg", {
  subject: "Norwood Fleet — Wednesday route",
});
console.log(group.last_operation?.status); // pending until WhatsApp reports back

group = client.whatsapp.groups.update(
    "wag_01krdgeqcxet5s7t44vh8rt9mg",
    subject="Norwood Fleet — Wednesday route",
)
print(group.last_operation)  # pending until WhatsApp reports back

group, err := client.Whatsapp.Groups.Update(context.Background(), "wag_01krdgeqcxet5s7t44vh8rt9mg", bird.WhatsappGroupsUpdateParams{
	Subject: bird.Ptr("Norwood Fleet — Wednesday route"),
})
if err != nil {
	log.Fatal(err)
}
fmt.Println(*group.LastOperation.Status) // pending until WhatsApp reports back

$group = $bird->whatsapp->groups->update(
    'wag_01krdgeqcxet5s7t44vh8rt9mg',
    (new WhatsAppGroupUpdate())->setSubject('Norwood Fleet — Wednesday route'),
);
echo $group->getLastOperation()?->getStatus(); // pending until WhatsApp reports back

bird whatsapp groups update wag_01krdgeqcxet5s7t44vh8rt9mg \
  --subject 'Norwood Fleet — Wednesday route'

curl -X PATCH "https://us1.platform.bird.com/v1/whatsapp/groups/wag_01krdgeqcxet5s7t44vh8rt9mg" \
  -H "Authorization: Bearer $BIRD_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"subject": "Norwood Fleet — Wednesday route"}'

WhatsApp aplica cada campo separadamente, então uma atualização pode ser parcialmente aplicada: um campo recusado enquanto os outros entram em vigor. Quando a operação se confirma, last_operation.results traz uma entrada por campo que a atualização enviou, que é como você associa uma recusa à entrada que a gerou.

profile_picture_url nomeia um arquivo na biblioteca de mídia do seu espaço de trabalho, e não um endereço na internet, e WhatsApp aceita um JPEG quadrado de pelo menos 192 por 192 pixels e até 5 MB. Limpá-lo remove a foto que Bird armazena, mas WhatsApp não tem operação para remover a foto de um grupo, então os participantes continuam vendo a atual até que outra foto a substitua. O número administrador e join_approval_mode são fixados na criação e não podem ser alterados aqui.

Remover um participante

A remoção não pode ser desfeita. WhatsApp impede que uma pessoa removida entre no grupo pelo link de convite, e o bloqueio acompanha a pessoa, não o link, então rotacionar o link não a deixa voltar. Sem operação de adição para combinar com esta, nada devolve alguém a este grupo depois de removido, e alcançá-lo de novo significa criar outro grupo e convidá-lo para ele.

Identifique a pessoa por qualquer um dos identificadores sob os quais o participants do grupo a lista: seu bsuid, que todos têm, ou seu phone_number no formato E.164, que está lá apenas quando WhatsApp o compartilha. Em uma URL, codifique o + inicial como %2B, a menos que seu cliente já faça isso.

const group = await bird.whatsapp.groups.participants.remove(
  "wag_01krdgeqcxet5s7t44vh8rt9mg",
  "+15550002222",
);
console.log(group.participants?.length);

group = client.whatsapp.groups.participants.remove(
    "wag_01krdgeqcxet5s7t44vh8rt9mg",
    "+15550002222",
)
print(len(group.participants or []))

group, err := client.Whatsapp.Groups.Participants.Remove(context.Background(), "wag_01krdgeqcxet5s7t44vh8rt9mg", "+15550002222")
if err != nil {
	log.Fatal(err)
}
if group.Participants != nil {
	fmt.Println(len(*group.Participants))
}

$group = $bird->whatsapp->groups->participants->remove(
    'wag_01krdgeqcxet5s7t44vh8rt9mg',
    '+15550002222',
);
echo count($group->getParticipants() ?? []);

bird whatsapp groups participants remove wag_01krdgeqcxet5s7t44vh8rt9mg +15550002222 --yes

curl -X DELETE "https://us1.platform.bird.com/v1/whatsapp/groups/wag_01krdgeqcxet5s7t44vh8rt9mg/participants/%2B15550002222" \
  -H "Authorization: Bearer $BIRD_API_KEY"

A remoção de um participante fica pending na entrada dele até WhatsApp confirmar, e nunca chega a success: a entrada desaparecendo de participants é o que indica que funcionou. Um valor nomeando alguém que não está no grupo retorna um 422 E15050.

Fixar uma mensagem

Fixar mantém uma das mensagens do próprio grupo no topo do chat, para que alguém que entre depois não precise rolar até o ponto ao qual a conversa sempre volta. Uma fixação dura duration_days, de 1 a 30, e o padrão é 7.

const pin = await bird.whatsapp.groups.pins.create("wag_01krdgeqcxet5s7t44vh8rt9mg", {
  message_id: "wam_01kya19eknftrs2s6p82asmvnh",
  duration_days: 14,
});
console.log(pin.pinned_until);

pin = client.whatsapp.groups.pins.create(
    "wag_01krdgeqcxet5s7t44vh8rt9mg",
    message_id="wam_01kya19eknftrs2s6p82asmvnh",
    duration_days=14,
)
print(pin.pinned_until)

pin, err := client.Whatsapp.Groups.Pins.Create(context.Background(), "wag_01krdgeqcxet5s7t44vh8rt9mg", bird.WhatsappGroupsPinsCreateParams{
	MessageID:    "wam_01kya19eknftrs2s6p82asmvnh",
	DurationDays: bird.Ptr(14),
})
if err != nil {
	log.Fatal(err)
}
fmt.Println(*pin.PinnedUntil)

$pin = $bird->whatsapp->groups->pins->create(
    'wag_01krdgeqcxet5s7t44vh8rt9mg',
    (new WhatsAppGroupPinnedMessageCreate())
        ->setMessageId('wam_01kya19eknftrs2s6p82asmvnh')
        ->setDurationDays(14),
);
echo $pin->getPinnedUntil()?->format(DATE_ATOM);

bird whatsapp groups pins create wag_01krdgeqcxet5s7t44vh8rt9mg \
  --message-id wam_01kya19eknftrs2s6p82asmvnh \
  --duration-days 14

curl -X POST "https://us1.platform.bird.com/v1/whatsapp/groups/wag_01krdgeqcxet5s7t44vh8rt9mg/pinned-messages" \
  -H "Authorization: Bearer $BIRD_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"message_id": "wam_01kya19eknftrs2s6p82asmvnh", "duration_days": 14}'

A mensagem precisa ser uma que este grupo contém: uma mensagem de outro grupo, ou uma mensagem individual, retorna um 422 E15053. Um grupo comporta apenas um certo número de fixações por vez, e fixar além disso desafixa a mais antiga em vez de falhar; fixar uma mensagem já fixada substitui sua expiração. O que o grupo tem fixado no momento está no próprio grupo, como pinned_messages.

WhatsApp desafixa uma mensagem automaticamente quando seus dias passam, então desafixe apenas para retirá-la antes do prazo. DELETE /v1/whatsapp/groups/{group_id}/pinned-messages/{message_id} responde 200, e repeti-lo é seguro: uma mensagem que este grupo contém mas que não está fixada não altera nada e ainda responde 200.

Excluir o grupo

Excluir remove o grupo em WhatsApp. Todos os participantes perdem o acesso, incluindo sua empresa, e o link de convite para de funcionar. Isso não pode ser desfeito, e retomar a conversa significa criar um novo grupo e enviar seu link.

const group = await bird.whatsapp.groups.delete("wag_01krdgeqcxet5s7t44vh8rt9mg");
console.log(group.last_operation?.status); // pending until WhatsApp confirms it

group = client.whatsapp.groups.delete("wag_01krdgeqcxet5s7t44vh8rt9mg")
if group.last_operation:
    print(group.last_operation.status)  # pending until WhatsApp confirms it

group, err := client.Whatsapp.Groups.Delete(context.Background(), "wag_01krdgeqcxet5s7t44vh8rt9mg")
if err != nil {
	log.Fatal(err)
}
fmt.Println(*group.LastOperation.Status) // pending until WhatsApp confirms it

$group = $bird->whatsapp->groups->delete('wag_01krdgeqcxet5s7t44vh8rt9mg');
echo $group->getLastOperation()?->getStatus(); // pending until WhatsApp confirms it

bird whatsapp groups delete wag_01krdgeqcxet5s7t44vh8rt9mg --yes

curl -X DELETE "https://us1.platform.bird.com/v1/whatsapp/groups/wag_01krdgeqcxet5s7t44vh8rt9mg" \
  -H "Authorization: Bearer $BIRD_API_KEY"

O grupo continua legível depois em status deleted, então uma referência armazenada a ele ainda resolve em vez de se tornar um 404. Um grupo failed também pode ser excluído, e esse não atinge nenhum sistema externo: a criação nunca produziu um grupo em WhatsApp, então limpar o registro é contabilidade interna de Bird. Qualquer outro status recusa com um 409 E15047.

Listar seus grupos

A lista retorna os grupos que seu espaço de trabalho criou, do mais recente ao mais antigo, como uma página paginada por cursor. Filtre pelo número administrador (number, como número E.164 ou ID wan_), pela WhatsApp Business Account sob a qual ele envia (waba), ou por status, repetindo o parâmetro para corresponder a vários. q pesquisa o assunto e a descrição por uma substring, sem distinção de maiúsculas e minúsculas.

for await (const group of bird.whatsapp.groups.list({ status: ["active"] })) {
  console.log(group.id, group.subject, group.participant_count);
}

for group in client.whatsapp.groups.list(status=["active"]):
    print(group.id, group.subject, group.participant_count)

for group, err := range client.Whatsapp.Groups.List(context.Background(), bird.WhatsappGroupsListParams{
	Status: []bird.WhatsAppGroupStatus{"active"},
}) {
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(*group.Id, group.Subject, *group.ParticipantCount)
}

foreach ($bird->whatsapp->groups->list(['status' => ['active']]) as $group) {
    echo $group->getId(), ' ', $group->getSubject(), PHP_EOL;
}

bird whatsapp groups list --status active

curl "https://us1.platform.bird.com/v1/whatsapp/groups?status=active" \
  -H "Authorization: Bearer $BIRD_API_KEY"

Um grupo excluído permanece na lista com status deleted, então filtre por status para ver apenas os grupos nos quais você ainda pode enviar mensagens.

Solução de problemas

• 412 (E15045): O número não possui o status de Official Business Account, então WhatsApp não o deixará criar um grupo. A decisão é de WhatsApp: solicite o status no WhatsApp Manager no perfil do número, ou crie o grupo em um número que já o possua.
• 404 (E15046): O ID não corresponde a nenhum grupo deste espaço de trabalho. Um grupo pertence ao espaço de trabalho que o criou, então um ID de outro espaço de trabalho não é encontrado aqui.
• 409 (E15047): O grupo está pendente, suspenso, excluído ou falhou. Apenas um grupo ativo aceita alterações. Leia o grupo para ver em que estado ele está.
• 409 (E15049): O número já administra os 10.000 grupos que WhatsApp permite. Exclua grupos cuja conversa já terminou ou crie este em outro número.
• 409 (E15054): Uma alteração no mesmo grupo ou no mesmo participante ainda está pendente. Leia last_operation e aguarde a confirmação.
• 422 (E15050): O caminho não identifica ninguém no grupo. Leia o participants do grupo e use um bsuid ou phone_number como ele os reporta.
• 422 (E15051): Um dos IDs de solicitação de entrada não está mais aguardando decisão. Liste as solicitações novamente e use os IDs que retornarem.
• 422 (E15053): A mensagem pertence a outro grupo ou a uma conversa individual. O to.group_id da mensagem indica qual grupo pode fixá-la.
• Um grupo pending que nunca se torna ativo: Bird desiste de esperar em vez de deixá-lo pendente e move o grupo para failed com o motivo em last_operation.last_error. Crie um substituto em vez de tentar novamente.

Referência

Os formatos completos de solicitação e resposta estão na referência API: criar, listar, obter, atualizar, excluir, rotacionar o link de convite, remover um participante, listar, aprovar e rejeitar solicitações de entrada, e fixar e desafixar uma mensagem.

Próximos passos

• Grupos WhatsApp: para que serve um grupo e o mesmo ciclo de vida no dashboard
• Enviando para um grupo WhatsApp: como endereçar o grupo, o que é necessário e os recibos por participante
• Recebendo mensagens de grupo WhatsApp: qual participante escreveu e como responder ao grupo
• IDs de usuário com escopo de negócio: o identificador pelo qual um participante é nomeado quando você não tem o número de telefone
• Idempotência: como tentar novamente uma escrita que pode já ter sido aceita