Gérer les groupes WhatsApp

Tout ce que fait la page Groups, douze opérations sous /v1/whatsapp/groups le font aussi, si bien que la vie entière d'un groupe tient dans du code : le créer, attendre que WhatsApp le confirme, distribuer son lien d'invitation, décider qui entre, maintenir ses détails et ses épingles à jour, et le supprimer quand la conversation est terminée.

Deux choses conditionnent chaque appel sur cette page. Personne ne peut être ajouté à un groupe : le lien d'invitation est le seul moyen d'y entrer, et inviter des personnes se fait en dehors de l'API. La plupart des modifications prennent effet côté WhatsApp et non dans la réponse : l'appel qui accepte une modification n'est pas celui qui vous confirme qu'elle a fonctionné ; Comment une modification prend effet couvre cela une fois pour toutes les opérations concernées.

Groupes WhatsApp explique à quoi sert un groupe et décrit le même cycle de vie dans le tableau de bord. Envoyer à un groupe WhatsApp couvre l'envoi de messages.

Prérequis

Vous avez besoin d'une clé API avec un accès whatsapp_management : niveau lecture pour les lectures de cette page, niveau écriture pour tout le reste. Utilisateurs, équipes et rôles explique comment l'accorder.

Vous avez aussi besoin d'un numéro professionnel disposant du statut Official Business Account, qu'WhatsApp exige de l'administrateur d'un groupe et que Avant de créer un groupe explique comment obtenir. GET /v1/whatsapp/numbers le signale par numéro sous is_official_business_account : consultez-le là plutôt que de le découvrir via une 412. L'indicateur correspond à l'état du numéro au moment de son meta_synced_at, donc un numéro connecté il y a quelques minutes peut ne pas encore avoir été relu.

Initialisez le client pour votre langage à l'aide du guide SDK TypeScript, Python, Go ou PHP. Pour les exemples CLI, installez et authentifiez le CLI. Les exemples cURL utilisent l'hôte US ; si votre clé commence par bk_eu1_, appelez https://eu1.platform.bird.com à la place. Les SDK détectent la région à partir de votre clé et ne définissent aucun hôte.

1. Créer le groupe

Une création nomme le numéro administrateur et un sujet, et personne d'autre. Deux choix sont fixés pour toute la vie du groupe et ne peuvent plus être modifiés ensuite : le numéro, et join_approval_mode, qui détermine si l'ouverture du lien d'invitation admet directement la personne (auto_approve, la valeur par défaut) ou génère une demande que vous traitez (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"
    }'

Le API renvoie 202 avec le groupe à l'état status pending et sans invite_link : WhatsApp émet le lien lorsqu'il confirme le groupe. Le sujet peut contenir jusqu'à 128 caractères et une description optionnelle jusqu'à 2 048, et les deux sont visibles par quiconque ouvre le lien : nommez donc le groupe selon sa finalité plutôt que comme référence interne.

2. Attendre la confirmation de WhatsApp

Relisez le groupe jusqu'à ce que son status quitte pending. La lecture répond 200 quel que soit le statut, alors branchez sur status plutôt que sur la réussite de l'appel.

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"

Cinq statuts peuvent revenir, et un seul correspond à un groupe utilisable :

failed est l'autre issue de pending, et last_operation.last_error.description contient la raison propre à WhatsApp. Ne réessayez jamais une création échouée sur ce groupe : créez-en un nouveau en corrigeant ce que le refus a contesté.

3. Faire entrer des personnes dans le groupe

Envoyez le invite_link du groupe aux personnes que vous souhaitez y voir, via le canal qui les atteint déjà. Aucune opération n'ajoute de participant : le lien est le seul moyen d'entrer et rejoindre le groupe reste leur décision. Il admet quiconque le détient, alors traitez-le comme l'identifiant qu'il est : Groupes WhatsApp indique jusqu'où le diffuser.

Dans un groupe auto_approve, quiconque détient le lien entre directement et il n'y a rien à décider. Dans un groupe approval_required, ouvrir le lien génère une demande d'adhésion. Listez celles en attente, puis décidez-les par lots de 50 maximum :

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 traite chaque demande individuellement, un lot peut donc être partiellement appliqué : la réponse sépare decided de failed, et chaque échec contient la raison fournie par WhatsApp dans error.description. Lisez la réponse plutôt que le code de statut. Un refus concerne souvent une personne qui n'a pas accepté les conditions en vigueur de WhatsApp, et aucun réessai ne corrige cela.

Approuver plus de personnes que le groupe ne peut en contenir ne refuse pas l'appel : les demandes qui tiennent sont traitées et les autres reviennent dans failed, chacune indiquant que l'approbation ferait dépasser la limite de participants du groupe. Le rejet fonctionne de la même manière, via POST /v1/whatsapp/groups/{group_id}/join-requests/batch-reject. Une demande quitte aussi la liste lorsque la personne l'annule elle-même, si bien qu'un ID valide un instant plus tôt peut renvoyer une 422 E15051 au moment où vous l'utilisez.

La limite de 50 est propre à Bird pour une seule requête, pas une limite WhatsApp : un balayage de rejets n'est donc pas contraint par le nombre de personnes que le groupe peut contenir.

Surveiller les demandes à mesure qu'elles arrivent

Abonnez-vous à whatsapp.group.join_request_created et whatsapp.group.join_request_revoked pour savoir quand quelqu'un demande à rejoindre le groupe et quand il annule, au lieu d'interroger la liste. Une demande émise et annulée entre deux lectures de la liste ne laisse aucune trace, ces événements sont donc le seul moyen de la voir. Chaque événement contient le join_request.id qu'utilisent les opérations par lot, vous pouvez donc décider directement à partir de celui-ci. Webhooks de groupe WhatsApp fournit les deux payloads et chaque champ.

Rotation du lien d'invitation

La rotation génère un nouveau lien et invalide tous les liens précédents du groupe, de sorte que quiconque en détient encore un ne peut plus rejoindre le groupe. Effectuez une rotation quand un lien s'est diffusé plus loin que prévu, ou après avoir retiré quelqu'un que vous ne voulez pas voir revenir. Le nouveau lien est renvoyé directement dans l'appel, qui répond 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"

La rotation ne sert pas à lire le lien actuel. Le groupe contient son invite_link, donc lire le groupe est la bonne lecture.

Le CLI ne demande jamais de confirmation, ses commandes destructives exigent donc --yes à la place : la rotation d'un lien, le retrait d'un participant, la suppression d'un groupe, le désépinglage d'un message et le rejet de demandes d'adhésion sont tous refusés avec confirmation_required sans ce paramètre.

Comment un changement se stabilise

WhatsApp confirme certains changements dans sa réponse et d'autres via un webhook, et le code de statut indique lequel des deux vous observez :

Pour les deux premières lignes, le 202 signifie que la requête est acceptée, pas appliquée. last_operation.status vaut pending jusqu'à ce que WhatsApp réponde, généralement en quelques secondes, puis se stabilise à success ou failed, avec last_error.description qui contient la raison en cas d'échec. Relisez le groupe pour voir ce qui a pris effet.

Tant qu'une opération est pending, un autre changement sur le même élément renvoie un 409 E15054. Les changements au niveau du groupe partagent le last_operation du groupe, donc un renommage en cours bloque une suppression. Chaque participant porte le sien, donc retirer plusieurs personnes à la fois donne à chacune son propre état et son propre échec, et seul le retrait en attente de cette personne bloque une nouvelle tentative la concernant.

Deux 409 protègent les écritures et status est vérifié en premier, donc un groupe qui n'est pas active renvoie E15047 quelle que soit la valeur de son last_operation. Cela compte pour un groupe encore en cours de création, qui est en attente sur les deux plans à la fois.

Chaque écriture prend aussi un en-tête Idempotency-Key. Idempotency couvre comment réessayer en toute sécurité.

Modifier le sujet, la description ou la photo du groupe

Une mise à jour modifie ce que les participants voient en haut du groupe. Les champs que vous omettez ne sont pas modifiés ; envoyez null pour effacer la description ou la photo, car une chaîne vide est un 422 plutôt qu'une deuxième façon d'effacer.

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 applique chaque champ séparément, une mise à jour peut donc être partiellement appliquée : un champ refusé tandis que les autres prennent effet. Quand l'opération se stabilise, last_operation.results contient une entrée par champ envoyé dans la mise à jour, ce qui permet de mettre un refus en regard de l'entrée qui l'a provoqué.

profile_picture_url désigne un fichier dans la bibliothèque média de votre espace de travail et non une adresse sur internet, et WhatsApp accepte un JPEG carré d'au moins 192 × 192 pixels et jusqu'à 5 Mo. L'effacer supprime la photo que Bird stocke, mais WhatsApp ne propose aucune opération pour retirer la photo d'un groupe, les participants continuent donc à voir la photo actuelle tant qu'une autre ne la remplace pas. Le numéro administrateur et join_approval_mode sont fixés à la création et ne peuvent pas être modifiés ici.

Retirer un participant

Le retrait est irréversible. WhatsApp empêche une personne retirée de rejoindre le groupe via le lien d'invitation, et le blocage suit la personne et non le lien, donc la rotation du lien ne la laisse pas revenir. Sans opération d'ajout pour accompagner celle-ci, rien ne ramène quelqu'un dans ce groupe une fois qu'il en est sorti, et le recontacter signifie créer un autre groupe et l'y inviter.

Désignez la personne par l'un ou l'autre des identifiants sous lesquels la liste participants du groupe la référence : son bsuid, que tout le monde possède, ou son phone_number au format E.164, qui n'est présent que lorsque WhatsApp le partage. Dans une URL, encodez en pourcentage le + initial sous la forme %2B, sauf si votre client le fait pour vous.

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"

Le retrait d'un participant est pending sur sa propre entrée jusqu'à ce que WhatsApp le confirme, et n'atteint jamais success : la disparition de l'entrée dans participants est ce qui indique que l'opération a réussi. Une valeur désignant quelqu'un qui n'est pas dans le groupe renvoie un 422 E15050.

Épingler un message

L'épinglage maintient l'un des messages du groupe en haut de sa conversation, pour qu'une personne qui rejoint plus tard n'ait pas à faire défiler jusqu'à ce que la conversation ne cesse de mentionner. Un épinglage dure duration_days, de 1 à 30, et la valeur par défaut est 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}'

Le message doit appartenir à ce groupe : un message d'un autre groupe, ou un message individuel, renvoie un 422 E15053. Un groupe ne peut contenir qu'un nombre limité d'épinglages simultanés, et épingler au-delà de cette limite désépingle le plus ancien au lieu d'échouer ; épingler un message déjà épinglé remplace son expiration. Ce que le groupe épingle actuellement se trouve sur le groupe lui-même, dans pinned_messages.

WhatsApp désépingle un message de lui-même une fois ses jours écoulés, donc ne désépinglez que pour le retirer plus tôt. DELETE /v1/whatsapp/groups/{group_id}/pinned-messages/{message_id} répond 200, et le répéter est sans risque : un message appartenant à ce groupe qui n'est pas épinglé ne change rien et répond quand même 200.

Supprimer le groupe

La suppression retire le groupe chez WhatsApp. Chaque participant perd l'accès, votre entreprise incluse, et le lien d'invitation cesse de fonctionner. Cette action est irréversible, et relancer la conversation signifie créer un nouveau groupe et envoyer son lien.

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"

Le groupe reste lisible après la suppression au statut status deleted, de sorte qu'une référence stockée continue de résoudre au lieu de devenir un 404. Un groupe failed peut aussi être supprimé, et celui-ci n'atteint aucun système externe : la création n'a jamais produit de groupe chez WhatsApp, donc la suppression de la ligne relève de la gestion interne de Bird. Tout autre statut refuse avec un 409 E15047.

Lister vos groupes

La liste renvoie les groupes créés par votre espace de travail, du plus récent au plus ancien, sous forme de page à curseur. Filtrez par numéro administrateur (number, en tant que numéro E.164 ou ID wan_), par le compte WhatsApp Business Account sous lequel il envoie (waba), ou par status, en répétant le paramètre pour correspondre à plusieurs valeurs. q recherche une sous-chaîne dans le sujet et la description, sans tenir compte de la casse.

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"

Un groupe supprimé reste dans la liste avec status deleted, donc filtrez par statut pour ne voir que les groupes auxquels vous pouvez encore envoyer des messages.

Dépannage

• 412 (E15045) : le numéro ne détient pas le statut Official Business Account, donc WhatsApp ne le laissera pas créer de groupe. La décision revient à WhatsApp : demandez le statut dans WhatsApp Manager sur le profil du numéro, ou créez le groupe sur un numéro qui le détient déjà.
• 404 (E15046) : l'ID ne désigne aucun groupe détenu par cet espace de travail. Un groupe appartient à l'espace de travail qui l'a créé, donc un ID provenant d'un autre espace de travail est introuvable ici.
• 409 (E15047) : le groupe est en attente, suspendu, supprimé ou échoué. Seul un groupe actif accepte un changement. Lisez le groupe pour voir où il en est.
• 409 (E15049) : le numéro administre déjà les 10 000 groupes autorisés par WhatsApp. Supprimez les groupes dont la conversation est terminée, ou créez celui-ci sur un autre numéro.
• 409 (E15054) : un changement sur le même groupe ou le même participant est encore en cours. Lisez last_operation et attendez qu'il se stabilise.
• 422 (E15050) : le chemin ne désigne personne dans le groupe. Lisez la liste participants du groupe et utilisez un bsuid ou phone_number tel qu'elle les rapporte.
• 422 (E15051) : l'un des ID de demande d'adhésion n'est plus en attente de décision. Listez à nouveau les demandes et utilisez les ID renvoyés.
• 422 (E15053) : le message appartient à un autre groupe ou à une conversation individuelle. Le to.group_id du message indique quel groupe peut l'épingler.
• Un groupe pending qui ne devient jamais actif : Bird cesse d'attendre au lieu de le laisser en attente, et fait passer le groupe à failed avec la raison dans last_operation.last_error. Créez un remplacement au lieu de réessayer.

Référence

Les structures complètes de requête et de réponse se trouvent dans la référence API : créer, lister, lire, mettre à jour, supprimer, effectuer la rotation du lien d'invitation, retirer un participant, lister, approuver et rejeter les demandes d'adhésion, et épingler et désépingler un message.

Étapes suivantes

• Groupes WhatsApp : à quoi sert un groupe, et le même cycle de vie dans le tableau de bord
• Envoyer à un groupe WhatsApp : adresser le groupe, ce que cela implique, et ses accusés de réception par participant
• Recevoir les messages d'un groupe WhatsApp : quel participant a écrit le message, et répondre au groupe
• Business-scoped user IDs : l'identifiant par lequel un participant est désigné quand vous n'avez pas de numéro de téléphone
• Idempotency : réessayer une écriture qui a peut-être déjà été acceptée