> ## Documentation Index
> Fetch the complete documentation index at: https://docs.querying.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Crédits et limites : prix, blocages, concurrence et limites de débit

> Ce que coûte chaque tâche, comment les crédits sont bloqués et prélevés, et les limites qui renvoient 429 ou 503.

Chaque tâche a un prix en crédits. Le prix est bloqué à la soumission, prélevé quand la tâche se termine et libéré si elle échoue. Votre plan fixe le nombre de tâches que vous pouvez avoir en file ou en cours à la fois.

Pour la liste à jour des moteurs et des prix, appelez l'endpoint public des capacités. Il ne demande pas de clé d'API :

```bash theme={"theme":"css-variables"}
curl https://api.querying.ai/v1/capabilities
```

Ajoutez `?taskType=GEMINI` pour lire un seul moteur. Les alias comme `GOOGLE_AIO` sont acceptés. Consultez [Obtenir les capacités](/fr/api-reference/capabilities.md).

## Crédits par tâche

| `taskType` | Crédits |
| - | - |
| `CHATGPT` | 1 par réponse. Chaque entrée de `payload.followUps` est une réponse supplémentaire. |
| `PERPLEXITY`, `BING_COPILOT`, `META_AI` | 1 |
| `GEMINI`, `GOOGLE` (`GOOGLE_AIO`), `AIMODE` (`GOOGLE_AIMODE`), `NAVER_AI_BRIEF`, `NAVER_AI_TAB`, `QWEN`, `DOUBAO` | 1,25 |
| `GOOGLE_SERP`, `NAVER_SERP`, `BING_SEARCH`, `REDDIT` | 1 |
| `COMMERCE_SERP` | 3 |
| `COMMERCE_PRODUCT` | 3 |
| `WEB_SCRAPE`, `WEB_MAP` | 1 |
| `WEB_CRAWL` | 1 par page renvoyée. Bloque `maxPages` crédits à la soumission ; les pages illisibles ne sont pas facturées. |
| `KEYWORD_VOLUME` | 3 par tâche (jusqu'à 100 mots-clés) |
| `PROMPT_RESEARCH` | 11 |
| `GEO_SCORE` | 10 par page, plus 5 par image dont le texte est lu (`images.read`, jusqu'à 12). Bloque 70 à la soumission ; les images illisibles ne sont pas facturées et une image qui réutilise une lecture des 90 derniers jours (`images.reused`) coûte 2. |
| `AI_RENDERING` ([AI Rendering](/fr/research/ai-rendering.md)) | 5 par rendu, plus 5 par image dont le texte est lu et 2 par image qui réutilise une lecture des 90 derniers jours, jusqu'à 12. Bloque 65 à la soumission. Une actualisation coûte autant. |
| Questions d'une recherche [Product Lookup](/fr/research/product-lookup.md#prix) | 10 par produit (le produit et chaque concurrent) et 5 par prompt d'achat, quels que soient les moteurs interrogés. Chaque question est une tâche de moteur facturée à sa part de ce prix, au lieu du prix du moteur ci-dessus. |
| Place Lookup (`POST /v1/place-lookup`) | 10 par recherche sur les moteurs par défaut du pays : 1 par question en `KR`, 1,25 ailleurs. Une recherche sur moins de moteurs paie les questions qu'elle envoie. Voir [Place Lookup](/fr/research/place-lookup.md). |
| `CITATION_ANALYSIS` | Facturé à l'usage, dans la limite du blocage. Voir ci-dessous. |

| Option | Crédits |
| - | - |
| `payload.include.analysis` | 2 en plus du prix du moteur, facturés uniquement quand `analysis.status` vaut `ok` |
| `payload.include.html` | 0,25 sur `CHATGPT`, `PERPLEXITY` et `META_AI`, facturés uniquement quand `html.status` vaut `ok`. Gratuit sur `GEMINI`, `GOOGLE` et `AIMODE`. |
| `payload.include.citationAnalysis` | Une tâche `CITATION_ANALYSIS` distincte, facturée à l'usage |
| Lecture des concurrents d'un moniteur | 80 crédits par 30 jours et par moniteur, répartis sur ses exécutions. Consultez [Suivi GEO](/fr/monitors.md#coût-et-calendrier). |

Les prix ne varient pas selon le plan ; c'est la valeur en dollars d'un crédit qui varie. Les crédits peuvent avoir deux décimales, comme `1.25`.

### Facturation Citation Analysis

Une tâche `CITATION_ANALYSIS` bloque `20 + 12 × citations + 80 × ⌈caractères de la réponse ÷ 1 000⌉` crédits à la soumission. À la fin, elle est facturée `1 + ⌈tokens en entrée ÷ 500⌉ + ⌈tokens en sortie ÷ 100⌉ + 2 × récupérations de sources`, jamais plus que le blocage. Le reste du blocage est libéré. Consultez [Citation Analysis](/fr/research/citation-analysis.md).

## Blocage, prélèvement et libération

**1. Soumission : blocage**

Le prix de la tâche (pour `WEB_CRAWL`, `GEO_SCORE` et `CITATION_ANALYSIS`, le maximum) passe de votre solde disponible à un blocage. Si le solde ne suffit pas, la soumission renvoie `402 INSUFFICIENT_CREDITS`. La réponse de soumission affiche `credits` à `0`.

**2. Terminée : prélèvement**

Le montant est pris sur le blocage. Un polling final et le webhook l'indiquent dans `creditsCharged`.

**3. Échouée : libération**

Le blocage revient sur votre solde. Une tâche échouée coûte `0`.

Un nouveau compte reçoit 500 crédits à l'inscription.

## Consulter votre solde

`GET /v1/credits` renvoie les crédits de votre compte. La lecture ne coûte rien : un programme peut le vérifier avant chaque lot. Consultez [Solde de crédits](/fr/api-reference/credits.md).

```bash theme={"theme":"css-variables"}
curl https://api.querying.ai/v1/credits \
  -H "Authorization: Bearer $QUERYING_API_KEY"
```

```json theme={"theme":"css-variables"}
{
  "success": true,
  "remaining": 1879939,
  "perCycle": 1000000,
  "cycleResetsAt": "2026-11-14T07:37:57.000Z",
  "reserved": 61,
  "plan": "max",
  "topUpBalance": { "credits": 1000000, "nextExpiresAt": "2027-01-19T10:01:57.000Z", "nextCredits": 1000000 }
}
```

* `remaining` correspond à ce que vous pouvez dépenser maintenant. Les tâches déjà soumises bloquent leur prix dans `reserved` : ne le soustrayez pas une seconde fois.
* `perCycle` est ce que votre plan accorde à chaque cycle, et `cycleResetsAt` la fin du cycle en cours. Les deux valent `null` sans plan actif.
* `topUpBalance` indique les crédits de recharge compris dans `remaining`, avec la date à laquelle les prochains expirent et leur nombre. Il vaut `null` si vous n'en avez pas. Les crédits de recharge durent trois mois après l'achat, sont conservés lors des renouvellements et sont dépensés après les crédits du plan.

La clé d'un sous-compte reçoit `403 SUB_ACCOUNT_FORBIDDEN`, car un sous-compte dépense vos crédits. Consultez [Sous-comptes](/fr/sub-accounts.md).

## Consulter votre utilisation

`GET /v1/usage` renvoie les crédits facturés à votre compte sur une plage de dates UTC, ventilés par jour, moteur et clé d'API selon votre choix. La lecture ne coûte rien. Consultez [Utilisation des crédits](/fr/api-reference/usage.md).

```bash theme={"theme":"css-variables"}
curl "https://api.querying.ai/v1/usage?from=2026-10-01&to=2026-10-20&groupBy=engine" \
  -H "Authorization: Bearer $QUERYING_API_KEY"
```

```json theme={"theme":"css-variables"}
{
  "success": true,
  "data": {
    "from": "2026-10-01",
    "to": "2026-10-20",
    "groupBy": ["engine"],
    "credits": 66.25,
    "tasks": 65,
    "rows": [
      { "taskType": "CHATGPT", "credits": 49, "tasks": 49 },
      { "taskType": "GEMINI", "credits": 6.25, "tasks": 5 },
      { "taskType": "PERPLEXITY", "credits": 11, "tasks": 11 }
    ]
  }
}
```

* `from` et `to` sont des dates UTC, et les deux jours sont inclus. Par défaut, ce sont le premier jour du mois UTC en cours et aujourd'hui. Une plage couvre 366 jours au plus.
* `groupBy` accepte `day`, `engine` et `key`, séparés par des virgules, et vaut `day,engine` par défaut. Une ligne porte les champs des ventilations choisies, et une combinaison sans facturation n'a pas de ligne. `credits` et `tasks` en tête additionnent toutes les lignes.
* `groupBy=key` montre qui a dépensé les crédits. Une tâche envoyée avec une clé d'API a `"source": "api"` et un `apiKey` avec son `id`, `keyPrefix`, `name` et `subAccountId`. Une dépense sans clé d'API a `source` à `monitor` (les exécutions d'un moniteur), `playground` ou `dashboard`, et `apiKey` vaut `null`.
* L'utilisation additionne ce qui a été facturé aux tâches, et une tâche échouée coûte `0`. La lecture des concurrents d'un moniteur est facturée sans tâche : elle fait baisser votre solde mais n'apparaît pas dans l'utilisation.
* Les tâches de vos [sous-comptes](/fr/sub-accounts.md) figurent dans votre utilisation, et `apiKey.subAccountId` désigne le sous-compte propriétaire d'une clé. [`GET /v1/sub-accounts/{id}/usage`](/fr/api-reference/sub-accounts/get-usage) lit un seul sous-compte. La clé d'un sous-compte reçoit `403 SUB_ACCOUNT_FORBIDDEN`.

## Consulter votre file

`GET /v1/async/status` renvoie vos tâches en file et en cours à côté de la limite de concurrence dans laquelle elles comptent. La lecture ne coûte rien. Consultez [État de la file](/fr/api-reference/queue-status.md).

```bash theme={"theme":"css-variables"}
curl https://api.querying.ai/v1/async/status \
  -H "Authorization: Bearer $QUERYING_API_KEY"
```

```json theme={"theme":"css-variables"}
{
  "success": true,
  "queuedTasks": 19,
  "processingTasks": 6,
  "priorityBreakdown": [{ "priority": 8, "count": 3 }, { "priority": 1, "count": 16 }],
  "concurrency": { "used": 25, "max": 200 }
}
```

* `concurrency.used` vaut `queuedTasks` plus `processingTasks`, les deux compteurs que la [limite de concurrence](#concurrence-du-plan) de votre plan additionne. `max` est cette limite : `max - used` est la place restante pour de nouvelles tâches.
* `priorityBreakdown` liste les tâches en file selon la `priority` avec laquelle elles ont été soumises, de la plus haute à la plus basse.
* Les compteurs incluent les tâches de vos sous-comptes, qui partagent votre limite. La clé d'un sous-compte reçoit `403 SUB_ACCOUNT_FORBIDDEN` et lit ses propres compteurs sur [`GET /stats`](/fr/api-reference/stats).

## Plans

| Plan | Prix mensuel | Crédits par mois | Tâches simultanées |
| - | - | - | - |
| Free | 0 \$ | 500 à l'inscription | 2 |
| Basic | 20 \$ | 8 000 | 50 |
| Pro | 200 \$ | 170 000 | 200 |
| Scale | 500 \$ | 480 000 | 500 |
| Max | 1 000 \$ | 1 000 000 | 1 000 |

Comparez les plans sur la [page des tarifs](https://querying.ai/fr/pricing).

### Concurrence du plan

La limite de concurrence compte ensemble les tâches `QUEUED` et `PROCESSING` de votre compte. Ce n'est pas une limite sur la vitesse de soumission. Une soumission qui la dépasserait renvoie `429 PLAN_CONCURRENCY_LIMIT` avec `details.limit`, `details.active` et `Retry-After`. Un contrat peut fixer une autre limite pour votre compte, et un compte parent peut en fixer une pour un [sous-compte](/fr/sub-accounts.md).

## Limites par clé et par sous-compte

| Limite | Où la définir | Quand elle est atteinte |
| - | - | - |
| Limite quotidienne de crédits d'une clé d'API | Gérer la clé dans le [tableau de bord](https://querying.ai/dashboard/keys), de 0,01 à 20 000 000 crédits | `429 KEY_DAILY_CREDIT_LIMIT` jusqu'au prochain minuit UTC. `Retry-After` compte les secondes restantes. |
| `monthlyCreditLimit` d'un sous-compte | Le compte parent. Consultez [Sous-comptes](/fr/sub-accounts.md). | `429 SUB_ACCOUNT_CREDIT_LIMIT` |

La limite quotidienne de la clé compte le blocage nécessaire à une tâche : une tâche est refusée quand `used + price` dépasserait la limite.

## Débit des requêtes et contre-pression

| Limite | Réponse |
| - | - |
| 1 200 requêtes par minute par identifiant `Authorization` sur `/v1/*` | `429` de l'edge |
| 6 000 requêtes par minute par IP source | `429` de l'edge |
| La file d'un moteur est pleine | `503 QUEUE_BACKPRESSURE` avec `Retry-After` |
| L'admission est saturée | `503 SERVER_OVERLOADED` avec `Retry-After` |
| La file globale des tâches est pleine | `503 SERVER_OVERLOADED` avec `Retry-After` |
| Un moteur n'accepte temporairement plus de tâches | `503 ENGINE_UNAVAILABLE` avec `Retry-After` |

Les `429` de l'edge interviennent avant l'API et ne portent ni l'enveloppe d'erreur JSON ni `Retry-After`. Espacez vos tentatives avec un délai exponentiel quand vous en recevez un. Un `429` ou un `503` des endpoints de soumission de tâches porte un en-tête `Retry-After` en secondes. Les codes et les conseils de nouvelle tentative figurent dans [Erreurs](/fr/concepts/errors.md).

## Cadencer les grosses soumissions

**1. Grouper au lieu de boucler**

Un `POST /v1/async/task/batch` de 500 éléments compte pour une seule requête dans la limite de l'edge. Au-delà de votre limite de concurrence, utilisez `POST /v1/batches` : le serveur libère les éléments à mesure que de la place se libère. Consultez [Lots et grilles](/fr/concepts/bulk-submission.md).

**2. Respecter Retry-After**

Attendez le nombre de secondes indiqué dans `Retry-After` avant de resoumettre une tâche refusée. Réutilisez le même `idempotencyKey` pour qu'une nouvelle tentative ne crée jamais de doublon.

**3. Séquencer le travail dépendant**

L'ordre d'exécution n'est pas garanti. Attendez qu'une tâche se termine avant de soumettre un travail qui dépend de son résultat.

**4. Surveiller vos compteurs**

[`GET /v1/async/status`](/fr/api-reference/queue-status) renvoie vos tâches en file et en cours à côté de la limite de votre plan, pour que vous restiez en dessous. [`GET /stats`](/fr/api-reference/stats) ajoute les tâches terminées au cours des dernières 24 heures.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.