Gestione dei gruppi WhatsApp

Tutto ciò che fa la pagina Groups lo fanno anche dodici operazioni sotto /v1/whatsapp/groups, così l'intero ciclo di vita di un gruppo sta nel codice: crearlo, attendere che WhatsApp lo confermi, distribuire il suo link di invito, decidere chi entra, tenere aggiornati i dettagli e i messaggi fissati, e cancellarlo quando la conversazione è finita.

Due aspetti condizionano ogni chiamata in questa pagina. Nessuno può essere aggiunto a un gruppo, quindi il link di invito è l'unico modo per entrare, e invitare le persone avviene al di fuori dell'API. La maggior parte delle modifiche si completa su WhatsApp anziché nella risposta, quindi la chiamata che accetta una modifica non è quella che ti dice che ha funzionato; Come si completa una modifica lo spiega una volta per ogni operazione a cui si applica.

Gruppi WhatsApp spiega a cosa serve un gruppo e lo stesso ciclo di vita nella dashboard. Inviare a un gruppo WhatsApp spiega come inviargli messaggi.

Prerequisiti

Serve una chiave API con accesso whatsapp_management: livello di lettura per le letture di questa pagina, livello di scrittura per tutto il resto. Users, teams, and roles spiega come concederlo.

Serve anche un numero business con lo status di Official Business Account, che WhatsApp richiede all'amministratore di un gruppo e che Before you create a group spiega come ottenere. GET /v1/whatsapp/numbers lo riporta per ogni numero come is_official_business_account, quindi leggilo lì anziché scoprirlo da un 412. Il flag è aggiornato al meta_synced_at del numero, quindi un numero connesso pochi minuti fa potrebbe non essere ancora stato riletto.

Inizializza il client per il tuo linguaggio usando la guida SDK per TypeScript, Python, Go o PHP. Per gli esempi CLI, installa e autentica il CLI. Gli esempi cURL indicano l'host US; se la tua chiave inizia con bk_eu1_, chiama https://eu1.platform.bird.com. Gli SDK leggono la regione dalla chiave, quindi non impostano alcun host.

1. Creare il gruppo

Una creazione specifica il numero amministratore e un oggetto, nessun altro. Due scelte sono fisse per tutta la vita del gruppo e non possono essere cambiate in seguito: il numero, e join_approval_mode, che decide se aprire il link di invito ammette qualcuno direttamente (auto_approve, il valore predefinito) o genera una richiesta che decidi tu (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"
    }'

API restituisce 202 con il gruppo allo stato status pending e senza invite_link: WhatsApp emette il link quando conferma il gruppo. L'oggetto può arrivare a 128 caratteri e una description opzionale a 2.048, ed entrambi sono visibili a chiunque apra il link: dai al gruppo un nome che ne descriva lo scopo, non un riferimento interno.

2. Attendere la conferma di WhatsApp

Rileggi il gruppo finché il suo status non esce da pending. La lettura risponde 200 qualunque sia lo stato, quindi controlla status anziché il buon esito della chiamata.

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"

Possono tornare cinque stati, e solo uno di essi è un gruppo con cui puoi lavorare:

failed è l'altra via d'uscita da pending, e last_operation.last_error.description riporta la motivazione fornita da WhatsApp. Non riprovare mai una creazione fallita sullo stesso gruppo: creane uno nuovo, modificando ciò che ha causato il rifiuto.

3. Far entrare le persone nel gruppo

Invia il invite_link del gruppo alle persone che vuoi far entrare, attraverso qualsiasi canale le raggiunga già. Nessuna operazione aggiunge un partecipante, quindi il link è l'unico modo per entrare e l'adesione è una loro decisione. Il link ammette chiunque lo possieda, quindi trattalo come la credenziale che è: Gruppi WhatsApp spiega quanto diffonderlo.

In un gruppo auto_approve, chiunque abbia il link entra direttamente e non c'è nulla da decidere. In un gruppo approval_required, aprire il link genera una richiesta di adesione. Elenca quelle in attesa, quindi decidile in blocchi fino a 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 ogni richiesta singolarmente, quindi un blocco è applicabile in parte: la risposta separa decided da failed, e ogni errore riporta la motivazione fornita da WhatsApp in error.description. Leggi la risposta anziché lo status code. Un rifiuto è spesso dovuto a una persona che non ha accettato i termini attuali di WhatsApp, e nessun nuovo tentativo lo risolve.

Approvare più persone di quante il gruppo possa contenere non rifiuta la chiamata: le richieste che rientrano nei limiti vengono decise e le restanti tornano in failed, ciascuna indicando che l'approvazione porterebbe il gruppo oltre il limite di partecipanti. Il rifiuto funziona allo stesso modo, tramite POST /v1/whatsapp/groups/{group_id}/join-requests/batch-reject. Una richiesta esce dalla lista anche quando la persona la annulla, quindi un ID valido un momento fa può restituire un 422 E15051 nel momento in cui lo usi.

Il limite di 50 è un vincolo di Bird sulla singola richiesta, non un limite di WhatsApp, quindi un'operazione di rifiuto massiva non è vincolata alla capienza del gruppo.

Monitorare le richieste man mano che arrivano

Iscriviti a whatsapp.group.join_request_created e whatsapp.group.join_request_revoked per sapere quando qualcuno chiede di entrare e quando annulla, invece di interrogare la lista periodicamente. Una richiesta sollevata e annullata tra due letture della lista non lascia traccia, quindi questi eventi sono l'unico modo per vederla. Ogni evento contiene il join_request.id usato dalle operazioni batch, così puoi decidere direttamente da esso. Webhook dei gruppi WhatsApp fornisce entrambi i payload e ogni campo.

Rotazione del link di invito

La rotazione genera un nuovo link e invalida tutti i link precedenti del gruppo, quindi chiunque ne possegga ancora uno non può entrare. Ruota quando un link si è diffuso più del previsto, o dopo aver rimosso qualcuno che non vuoi far rientrare. Il nuovo link viene restituito nella chiamata stessa, che risponde 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 rotazione non è il modo per leggere il link attuale. Il gruppo contiene il proprio invite_link, quindi leggere il gruppo è la lettura.

La CLI non chiede mai conferma, quindi i suoi comandi distruttivi richiedono --yes: ruotare un link, rimuovere un partecipante, eliminare un gruppo, rimuovere un messaggio fissato e rifiutare richieste di adesione vengono tutti rifiutati con confirmation_required senza di esso.

Come si stabilizza una modifica

WhatsApp conferma alcune modifiche nella risposta e altre tramite webhook, e il codice di stato indica quale tipo stai osservando:

Per le prime due righe, il 202 indica che la richiesta è stata accettata, non applicata. last_operation.status è pending fino a quando WhatsApp non risponde, di solito entro pochi secondi, poi si stabilizza su success o failed, con last_error.description che riporta il motivo in caso di fallimento. Rileggi il gruppo per vedere cosa ha avuto effetto.

Mentre un'operazione è pending, un'altra modifica allo stesso elemento restituisce un 409 E15054. Le modifiche a livello di gruppo condividono il last_operation del gruppo, quindi una rinomina in corso blocca un'eliminazione. Ogni partecipante ha il proprio, quindi rimuovere più persone contemporaneamente assegna a ciascuna il proprio stato e il proprio errore, e solo la rimozione in sospeso di quella persona blocca un altro tentativo su di essa.

Due 409 proteggono le scritture e status viene controllato per primo, quindi un gruppo che non è active restituisce E15047 indipendentemente da ciò che dice il suo last_operation. Questo è rilevante per un gruppo ancora in fase di creazione, che è in sospeso su entrambi i fronti contemporaneamente.

Ogni scrittura accetta anche un header Idempotency-Key. Idempotency spiega come riprovare in sicurezza.

Modificare oggetto, descrizione o immagine del gruppo

Un aggiornamento cambia ciò che i partecipanti vedono in cima al gruppo. I campi che ometti restano invariati; invia null per cancellare la descrizione o l'immagine, poiché una stringa vuota è un 422 e non un secondo modo per cancellare.

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 applica ogni campo separatamente, quindi un aggiornamento può essere applicato parzialmente: un campo rifiutato mentre gli altri hanno effetto. Quando l'operazione si stabilizza, last_operation.results contiene una voce per ogni campo inviato nell'aggiornamento, ed è così che puoi associare un rifiuto all'input che lo ha causato.

profile_picture_url indica un file nella libreria multimediale del tuo spazio di lavoro e non un indirizzo qualsiasi su internet, e WhatsApp accetta un JPEG quadrato di almeno 192 × 192 pixel e fino a 5 MB. Cancellarlo rimuove l'immagine che Bird conserva, ma WhatsApp non ha un'operazione per togliere la foto di un gruppo, quindi i partecipanti continuano a vedere quella attuale fino a quando un'altra immagine la sostituisce. Il numero di amministrazione e join_approval_mode sono fissati al momento della creazione e non possono essere modificati qui.

Rimuovere un partecipante

La rimozione non può essere annullata. WhatsApp impedisce a una persona rimossa di rientrare nel gruppo tramite link di invito, e il blocco segue la persona e non il link, quindi ruotare il link non la fa rientrare. Senza un'operazione di aggiunta da abbinare a questa, nulla riporta qualcuno in questo gruppo una volta uscito, e raggiungerlo di nuovo significa creare un altro gruppo e invitarlo.

Indica la persona con uno dei due identificativi sotto cui la lista participants del gruppo la riporta: il suo bsuid, che tutti hanno, o il suo phone_number in formato E.164, presente solo quando WhatsApp lo condivide. In un URL, codifica in percentuale il + iniziale come %2B, a meno che il tuo client non lo faccia già.

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"

La rimozione di un partecipante è pending sulla sua voce fino a quando WhatsApp non la conferma, e non raggiunge mai success: la scomparsa della voce da participants è ciò che conferma che ha funzionato. Un valore che indica qualcuno che non è nel gruppo restituisce un 422 E15050.

Fissare un messaggio

Fissare un messaggio lo mantiene in cima alla chat del gruppo, così chi entra dopo non deve scorrere per trovare il punto a cui la conversazione continua a tornare. Un messaggio fissato dura duration_days, da 1 a 30, con valore predefinito 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}'

Il messaggio deve appartenere a questo gruppo: un messaggio di un altro gruppo, o un messaggio uno a uno, restituisce un 422 E15053. Un gruppo può contenere solo un certo numero di messaggi fissati contemporaneamente, e fissarne oltre quel limite rimuove il più vecchio invece di fallire; fissare un messaggio già fissato ne sostituisce la scadenza. I messaggi attualmente fissati dal gruppo si trovano nel gruppo stesso, come pinned_messages.

WhatsApp rimuove automaticamente un messaggio fissato una volta trascorsi i suoi giorni, quindi usa unpin solo per rimuoverlo in anticipo. DELETE /v1/whatsapp/groups/{group_id}/pinned-messages/{message_id} risponde 200, e ripeterlo è sicuro: un messaggio appartenente a questo gruppo che non è fissato non cambia nulla e risponde comunque 200.

Eliminare il gruppo

L'eliminazione rimuove il gruppo su WhatsApp. Ogni partecipante perde l'accesso, compresa la tua azienda, e il link di invito smette di funzionare. L'operazione non può essere annullata, e riprendere la conversazione significa creare un nuovo gruppo e inviarne il 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"

Il gruppo resta leggibile dopo l'eliminazione con status deleted, quindi un riferimento salvato continua a risolversi invece di diventare un 404. Anche un gruppo failed può essere eliminato, e in quel caso non viene raggiunto alcun sistema esterno: la creazione non ha mai prodotto un gruppo su WhatsApp, quindi la cancellazione della riga è una gestione interna di Bird. Ogni altro stato rifiuta con un 409 E15047.

Elencare i tuoi gruppi

L'elenco restituisce i gruppi creati dal tuo spazio di lavoro, dal più recente, come pagina a cursore. Filtra per numero di amministrazione (number, come numero E.164 o ID wan_), per il Business Account WhatsApp sotto cui invia (waba), o per status, ripetendo il parametro per corrispondere a più valori. q cerca una sottostringa nell'oggetto e nella descrizione, senza distinzione tra maiuscole e minuscole.

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 gruppo eliminato resta nell'elenco con status deleted, quindi filtra per stato per vedere solo i gruppi a cui puoi ancora inviare messaggi.

Risoluzione dei problemi

• 412 (E15045): il numero non possiede lo stato Official Business Account, quindi WhatsApp non gli consente di creare un gruppo. La decisione è di WhatsApp: richiedi lo stato nel WhatsApp Manager sul profilo del numero, oppure crea il gruppo su un numero che lo possiede già.
• 404 (E15046): l'ID non corrisponde ad alcun gruppo di questo spazio di lavoro. Un gruppo appartiene allo spazio di lavoro che lo ha creato, quindi un ID proveniente da un altro spazio di lavoro non viene trovato qui.
• 409 (E15047): il gruppo è in sospeso, sospeso, eliminato o fallito. Solo un gruppo attivo accetta modifiche. Leggi il gruppo per verificarne lo stato.
• 409 (E15049): il numero amministra già i 10.000 gruppi consentiti da WhatsApp. Elimina i gruppi la cui conversazione è terminata, oppure crea questo su un altro numero.
• 409 (E15054): una modifica allo stesso gruppo o allo stesso partecipante è ancora in corso. Leggi last_operation e attendi che si stabilizzi.
• 422 (E15050): il percorso non indica nessuno nel gruppo. Leggi la lista participants del gruppo e usa un bsuid o phone_number come riportati.
• 422 (E15051): uno degli ID delle richieste di adesione non è più in attesa di decisione. Elenca di nuovo le richieste e usa gli ID restituiti.
• 422 (E15053): il messaggio appartiene a un altro gruppo o a una conversazione uno a uno. Il to.group_id di un messaggio indica quale gruppo può fissarlo.
• Un gruppo pending che non diventa mai attivo: Bird rinuncia ad attendere invece di lasciarlo in sospeso, e sposta il gruppo su failed con il motivo in last_operation.last_error. Crea un sostituto invece di riprovare.

Riferimento

Le strutture complete di richiesta e risposta si trovano nel riferimento API: create, list, get, update, delete, rotazione del link di invito, rimozione di un partecipante, elenco, approvazione e rifiuto delle richieste di adesione, e fissaggio e rimozione fissaggio di un messaggio.

Passaggi successivi

• Gruppi WhatsApp: a cosa serve un gruppo e lo stesso ciclo di vita nella dashboard
• Invio a un gruppo WhatsApp: indirizzamento del gruppo, requisiti e ricevute per partecipante
• Ricezione di messaggi di gruppo WhatsApp: quale partecipante ha scritto il messaggio e come rispondere al gruppo
• ID utente con ambito business: l'identificativo con cui viene indicato un partecipante quando non si dispone del numero di telefono
• Idempotency: riprovare una scrittura che potrebbe essere già stata accettata