# Errore WhatsApp 80007: limite di frequenza dell'account raggiunto — soluzione

URL: https://wa.genuka.com/it/docs/errors/80007
Language: Italian

> Errore WhatsApp 80007: il WhatsApp Business Account ha raggiunto il suo limite di chiamate API (200 o 5.000 all'ora). Quali chiamate contano, e come evitarlo.

L'errore WhatsApp 80007 significa che un'applicazione ha fatto troppe chiamate su uno stesso account
WhatsApp Business nell'arco di un'ora: 200 per impostazione predefinita, 5.000 per un account attivo
con un numero registrato. Le chiamate che contano sono quelle di gestione dell'account, come modelli
e numeri di telefono, non gli invii di messaggi. Aspetta, poi chiama meno spesso.

## Cosa significa l'errore 80007?

Meta lo elenca tra gli errori di limitazione:

> "The WhatsApp Business Account has reached its rate limit."
> — [Meta, Cloud API error codes](https://developers.facebook.com/documentation/business-messaging/whatsapp/support/error-codes#throttling-errors)

Soluzione suggerita: consultare i limiti di frequenza dell'account WhatsApp Business, poi "try again
later or reduce the frequency or amount of API queries the app is making".

Quei limiti sono descritti nella panoramica della piattaforma: le richieste di un'app su un account
vengono contate su un'ora mobile, a 200 all'ora, per app, per account per impostazione predefinita,
e a 5.000 all'ora per un account attivo con almeno un numero di telefono registrato
([Meta, About the platform](https://developers.facebook.com/documentation/business-messaging/whatsapp/about-the-platform#rate-limits)).
Coprono questi endpoint:

| Richiesta               | Endpoint                              |
| ----------------------- | ------------------------------------- |
| `GET`                   | `/{WABA_ID}`                          |
| `GET`, `POST`, `DELETE` | `/{WABA_ID}/assigned_users`           |
| `GET`                   | `/{WABA_ID}/phone_numbers`            |
| `GET`, `POST`, `DELETE` | `/{WABA_ID}/message_templates`        |
| `GET`, `POST`, `DELETE` | `/{WABA_ID}/subscribed_apps`          |
| `GET`                   | `/{WABA_TO_NUMBER_CURRENT_STATUS_ID}` |

La pagina generale sui limiti di frequenza della Graph API collega inoltre il codice `80008` al tipo
di limite "WhatsApp Business Management API". Gestiscili entrambi allo stesso modo
([Meta, Rate limits](https://developers.facebook.com/docs/graph-api/overview/rate-limiting)).

## Quando si verifica l'errore 80007?

* **Polling dei modelli.** Rileggere l'elenco dei modelli ogni minuto per vedere se uno è stato
  approvato costa 60 chiamate all'ora su quell'account, prima di qualsiasi altra cosa.
* **Creazione di modelli in massa.** Uno script che invia, elimina e ricrea decine di modelli uno
  dopo l'altro.
* **Un account non ancora attivo.** Finché non vi è registrato un numero, l'account resta a 200
  chiamate all'ora.

### Dove lo vedi in Genuka WA?

Il limite viene contato per applicazione **e** per account WhatsApp. Con Genuka WA l'applicazione è
quella di Genuka: tutte le chiamate fatte sull'account di un cliente si sommano, che vengano dal tuo
codice, dalla dashboard o dal portale cliente. In compenso, l'account di un cliente non consuma mai
il limite di un altro cliente.

Dal lato di Genuka WA, queste chiamate passano di qui:

| Endpoint di Genuka WA                                            | Chiamata Meta conteggiata                                                       |
| ---------------------------------------------------------------- | ------------------------------------------------------------------------------- |
| `POST /api/v1/templates`                                         | `POST /{WABA_ID}/message_templates`                                             |
| `DELETE /api/v1/templates/{id}`                                  | `DELETE /{WABA_ID}/message_templates`                                           |
| `POST /api/v1/templates/sync`, `GET /api/v1/templates?sync=true` | `GET /{WABA_ID}/message_templates`, una volta per ogni account WhatsApp coperto |

Genuka colloca il codice 80007 nella classe `retryable`. Una creazione di modello rifiutata torna
come `422 meta_rejected` con `meta.retryable: true`, oppure come `502` se Meta ha risposto con un
429 o un 5xx. Un aggiornamento resta un `200` finché almeno un account ha risposto: l'account
limitato mostra `"ok": false` con il motivo di Meta in `error`. Se tutti gli account hanno
rifiutato, la risposta è un `502 meta_rejected`.

Un `502` ti arriva senza corpo JSON: la nostra CDN lo sostituisce con la sola riga
`error code: 502` ([riferimento API](https://wa.genuka.com/it/docs/api)). Leggi lo stato HTTP prima del corpo, e tratta
questo caso come un errore temporaneo.

## Come risolvo l'errore 80007?

1. **Smetti di chiedere ciò che arriva da solo.** La revisione di un modello arriva via webhook, come
   evento `message_template_status_update` ([Webhook](https://wa.genuka.com/it/docs/webhooks)). Iscrivi un endpoint a
   quell'evento ed elimina il ciclo di lettura.
2. **Riserva l'aggiornamento alle riparazioni.** `POST /api/v1/templates/sync` esiste per recuperare
   un webhook perso: una volta all'ora è più che sufficiente, e `companyId` o `connectionId` lo
   restringono all'unico account interessato ([riferimento API](https://wa.genuka.com/it/docs/api#modelli)).
3. **Riprova più tardi ciò che è stato rifiutato.** Una creazione di modello segnata come `retryable`
   può essere inviata di nuovo dopo un'attesa; il limite si libera man mano che l'ora mobile avanza.
4. **Distribuisci nel tempo la creazione in massa.** Invia i modelli di un nuovo cliente in piccoli
   lotti invece che in un'unica raffica.

Se chiami tu stesso la Graph API, l'header `X-Business-Use-Case-Usage` indica la quota di chiamate
utilizzata (`call_count`) e, una volta limitato, `estimated_time_to_regain_access`, il numero di
minuti prima che tutto torni alla normalità
([Meta, Rate limits](https://developers.facebook.com/docs/graph-api/overview/rate-limiting)).

**Node.js**

```ts
// Un aggiornamento all'ora, ristretto a un cliente, segnalando gli account che hanno fallito.
const response = await fetch("https://wa.genuka.com/api/v1/templates/sync", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.GENUKA_WA_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({ companyId: "cmp_1" }),
});
// Un 502 arriva senza JSON: la nostra CDN lo sostituisce con "error code: 502".
const json = await response.json().catch(() => null);

if (!response.ok) {
  console.error("Nessun account ha risposto", response.status, json?.message ?? "");
} else {
  for (const waba of json.data.wabas.filter((w: { ok: boolean }) => !w.ok)) {
    console.warn("Account non aggiornato, riprova tra un'ora", waba.wabaId, waba.error);
  }
}
```

**Python**

```python
import os
import requests

response = requests.post(
    "https://wa.genuka.com/api/v1/templates/sync",
    headers={"Authorization": f"Bearer {os.environ['GENUKA_WA_API_KEY']}"},
    json={"companyId": "cmp_1"},
    timeout=60,
)
try:
    body = response.json()
except ValueError:
    body = {}  # un 502 arriva senza JSON: la nostra CDN lo sostituisce con "error code: 502"

if not response.ok:
    print("Nessun account ha risposto", response.status_code, body.get("message"))
else:
    for waba in body["data"]["wabas"]:
        if not waba["ok"]:
            print("Account non aggiornato, riprova tra un'ora", waba["wabaId"], waba.get("error"))
```

**PHP**

```php
<?php
$ch = curl_init("https://wa.genuka.com/api/v1/templates/sync");
curl_setopt_array($ch, [
    CURLOPT_POST => true,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_USERAGENT => "acme-crm/1.0 (+https://example.com)",
    CURLOPT_HTTPHEADER => [
        "Authorization: Bearer " . getenv("GENUKA_WA_API_KEY"),
        "Content-Type: application/json",
    ],
    CURLOPT_POSTFIELDS => json_encode(["companyId" => "cmp_1"]),
]);
$raw = curl_exec($ch);
$status = curl_getinfo($ch, CURLINFO_RESPONSE_CODE); // 0 quando la richiesta non si è mai conclusa
curl_close($ch);
// Un 502 arriva senza JSON: la nostra CDN lo sostituisce con "error code: 502".
$body = is_string($raw) ? json_decode($raw, true) : null;

if ($status === 0 || $status >= 400 || !is_array($body)) {
    error_log("Nessun account ha risposto: HTTP $status " . ($body["message"] ?? ""));
} else {
    foreach ($body["data"]["wabas"] as $waba) {
        if (!$waba["ok"]) error_log("Account non aggiornato: {$waba['wabaId']} " . ($waba["error"] ?? ""));
    }
}
```

**curl**

```bash
# Un 502 arriva come testo semplice ("error code: 502"), che jq non riesce a leggere.
curl -s -X POST https://wa.genuka.com/api/v1/templates/sync \
  -H "Authorization: Bearer $GENUKA_WA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{ "companyId": "cmp_1" }' \
  | jq '.data.wabas[] | select(.ok == false)'
```

## Come prevengo l'errore 80007?

* **Prima i webhook.** Lo stato di un modello, un cambiamento di qualità o un aggiornamento
  dell'account ti raggiungono senza che tu debba chiederli.
* **Un aggiornamento programmato, non uno scatenato dalle visite alla pagina.** Una dashboard che
  rilegge Meta a ogni apertura moltiplica le chiamate per il numero di visitatori.
* **Collega il numero prima di creare i modelli.** Un account attivo con un numero registrato ha
  5.000 chiamate all'ora invece di 200.

## Codici di errore correlati

* [4](https://wa.genuka.com/it/docs/errors/4): il limite di chiamate dell'intera applicazione.
* [130429](https://wa.genuka.com/it/docs/errors/130429): il throughput di messaggi di un numero.
* `80008`: il codice che la pagina sui limiti di frequenza della Graph API collega alla WhatsApp
  Business Management API.

## FAQ

### Perché il mio account è limitato a 200 chiamate all'ora invece di 5.000?

Meta riserva le 5.000 chiamate all'ora agli account attivi con almeno un numero registrato. Un
account creato senza numero, o il cui numero non è ancora registrato, resta a 200.

### Gli invii di messaggi contano per questo limite?

Gli endpoint che Meta elenca per questo limite sono quelli di gestione dell'account, non gli invii.
Gli invii hanno i loro tetti, tra cui il throughput per numero, codice
[130429](https://wa.genuka.com/it/docs/errors/130429).

### L'account di un cliente può esaurire il limite di un altro?

No. Il limite viene contato per applicazione e per account WhatsApp: ogni account ha il suo.

## Fonti

* [Meta — Error codes](https://developers.facebook.com/documentation/business-messaging/whatsapp/support/error-codes)
* [Meta — About the platform, rate limits](https://developers.facebook.com/documentation/business-messaging/whatsapp/about-the-platform#rate-limits)
* [Meta — Graph API, Rate limits](https://developers.facebook.com/docs/graph-api/overview/rate-limiting)
