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

# Limites et dépenses

> Ce qui peut s'épuiser dans votre organisation, les deux en-têtes qui le signalent, et comment lire le coût d'un flux.

Vos propres clés de fournisseur n'ont pas de plafond financier. Les clés gérées (Managed Keys) dépensent un solde prépayé, elles peuvent donc s'épuiser.

Deux en-têtes de réponse signalent ce qu'il vous reste. `GET /v1/limits` fournit une vue d'ensemble complète en un seul appel.

## Vos propres clés n'ont pas de plafond financier

Nous ne fixons aucune allocation de requêtes ni aucun plafond mensuel. Vous ne détenez aucun solde à épuiser. Consultez [tarification et facturation](/fr/billing).

Un seul plafond s'applique. Votre organisation exécute un nombre fixe de flex races simultanément. Au-delà de ce nombre, nous exécutons la requête sur le niveau standard. Vous perdez la réduction, pas la réponse. Le rapport nomme ce nombre `own_keys.flex_race_slots`.

## Ce qui peut s'épuiser avec les clés gérées (Managed Keys)

| Plafond                          | Ce qu'il compte                                                                                                               | Au plafond                                                                                 |
| :------------------------------- | :---------------------------------------------------------------------------------------------------------------------------- | :----------------------------------------------------------------------------------------- |
| Solde prépayé                    | D'abord l'argent, puis les crédits promotionnels.                                                                             | [`insufficient_balance`](/fr/errors#insufficient_balance), statut `402`.                   |
| Plafond de dépenses quotidiennes | Dépenses réglées aujourd'hui, plus les requêtes en cours d'aujourd'hui. La fenêtre est un jour UTC.                           | [`spend_velocity_exceeded`](/fr/errors#spend_velocity_exceeded), statut `429`.             |
| Concurrence gérée                | Vos requêtes gérées en cours.                                                                                                 | [`rate_limit_exceeded`](/fr/errors#rate_limit_exceeded), statut `429`, avec `Retry-After`. |
| Taux du pool partagé             | Requêtes par minute sur un pool partagé par toutes les organisations gérées. Aujourd'hui, il s'agit de Workers AI et Foundry. | [`rate_limit_exceeded`](/fr/errors#rate_limit_exceeded), statut `429`.                     |

Un examen des risques peut suspendre les requêtes gérées en plus de ces quatre limites. Il renvoie [`account_under_review`](/fr/errors#account_under_review). Vos propres routes de clés continuent de fonctionner.

Quatre autres limites couvrent toutes les organisations. Trois comptent les requêtes par minute provenant d'une organisation, d'une clé et d'une adresse IP. La quatrième compte les tentatives d'authentification échouées depuis une adresse IP. Nous refusons également un corps de requête de plus de 50 000 000 octets comme [`request_too_large`](/fr/errors#request_too_large).

Le rapport nomme chaque limite par minute avec sa fenêtre et sa portée. Il omet le nombre, car Cloudflare compte chacune d'elles dans chaque emplacement où elle s'exécute, et un seul nombre ne constituerait pas un budget sur lequel vous pourriez vous baser. Attendez plutôt le nombre de secondes indiqué dans `Retry-After`.

## Deux en-têtes de réponse signalent vos dépenses

Une réponse avec vos propres clés les contient une fois que ses routes sont résolues, et une réponse gérée les contient dès la retenue du solde.

Trois types de réponses n'ont aucun de ces en-têtes : une que nous avons refusée plus tôt, le catalogue de modèles, et une requête gérée dont nous n'avons pas pu lire le solde. Nous omettons les en-têtes plutôt que de deviner.

| En-tête                           | Ce qu'il indique                                                                                                                                                                         |
| :-------------------------------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `x-flexinference-spend-remaining` | Le mot `unlimited` lorsqu'aucun plafond financier ne s'applique. Sinon, un entier micro-USD signé. C'est le plus petit de votre solde et de ce que le plafond quotidien autorise encore. |
| `x-flexinference-spend-as-of`     | Quand nous avons lu ce nombre, en millisecondes Unix. Il n'est présent qu'avec un nombre, car `unlimited` n'a pas besoin de marque de fraîcheur.                                         |

Nous lisons les deux au moment où nous avons admis cette requête. Le nombre couvre ce qu'il vous restait avant que cette requête ne règle son propre coût.

Un nombre négatif signifie que nous refusons toute requête gérée. L'ajout d'argent répare un solde négatif. Un solde quotidien négatif se rétablit au prochain minuit UTC ou avec un plafond relevé, jamais avec une recharge.

Lisez ces en-têtes sur le trafic que vous envoyez déjà. Interroger le point de terminaison avant chaque requête coûte un aller-retour et ne vous en dit pas plus que l'en-tête.

## Le point de terminaison des limites

`GET /v1/limits` prend votre clé FlexInference. Il signale les plafonds sous lesquels votre organisation fonctionne. Il lit les enregistrements qui admettent vos requêtes, il ne revendique donc jamais un espace que nous refuserions. Nous ne mettons jamais la réponse en cache.

```bash theme={null}
curl https://api.flexinference.com/v1/limits \
  -H "Authorization: Bearer $FLEXINFERENCE_API_KEY"
```

```json theme={null}
{
  "object": "limits",
  "as_of": 1769558400123,
  "own_keys": {
    "unlimited": true,
    "flex_race_slots": {
      "limit": 40,
      "scope": "organization",
      "on_exceed": "degrade_to_standard"
    }
  },
  "managed": {
    "providers": ["anthropic", "openai"],
    "serving": "ok",
    "paused_reason": null,
    "binding": "daily_spend",
    "spend_remaining_micro_usd": 41200000,
    "currency": "USD",
    "balance": {
      "remaining_micro_usd": 94880000,
      "cash_micro_usd": 84880000,
      "credit_micro_usd": 10000000,
      "reserved_micro_usd": 120000
    },
    "daily_spend": {
      "limit_micro_usd": 250000000,
      "used_micro_usd": 208800000,
      "remaining_micro_usd": 41200000,
      "window": "utc_day",
      "resets_at": 1769644800
    },
    "concurrency": {
      "limit": 10,
      "scope": "organization",
      "on_exceed": "refuse"
    },
    "ramp_week": 1,
    "ramp_defaults": {
      "concurrency": 10,
      "daily_spend_micro_usd": 250000000
    },
    "override_in_force": {
      "concurrency": false,
      "daily_spend": false
    },
    "rates": []
  },
  "abuse_limits": {
    "counted_per_cloudflare_location": true,
    "request_body_bytes": 50000000,
    "rates": [
      {
        "name": "organization_requests",
        "scope": "organization",
        "window_seconds": 60,
        "limit": null,
        "on_exceed": "refuse"
      },
      {
        "name": "api_key_requests",
        "scope": "api_key",
        "window_seconds": 60,
        "limit": null,
        "on_exceed": "refuse"
      },
      {
        "name": "client_ip_requests",
        "scope": "client_ip",
        "window_seconds": 60,
        "limit": null,
        "on_exceed": "refuse"
      },
      {
        "name": "failed_authentications",
        "scope": "client_ip",
        "window_seconds": 60,
        "limit": null,
        "on_exceed": "refuse"
      }
    ]
  }
}
```

Chaque champ monétaire est un entier micro-USD. Un USD équivaut à 1 000 000 de ces unités.

| Champ                               | Ce qu'il indique                                                                                                                                                                                                   |
| :---------------------------------- | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `as_of`                             | Millisecondes Unix. L'horloge propre au solde lorsque nous lisons un solde, et la nôtre lorsque nous ne le faisons pas.                                                                                            |
| `own_keys.unlimited`                | Toujours `true`.                                                                                                                                                                                                   |
| `own_keys.flex_race_slots`          | Combien de flex races s'exécutent simultanément. Dépasser ce nombre coûte la réduction, pas la réponse.                                                                                                            |
| `managed`                           | `null` lorsqu'aucun fournisseur ne sert sur des clés gérées.                                                                                                                                                       |
| `managed.serving`                   | `ok`, ou `paused` dans chacun des trois états qui refusent toute requête gérée.                                                                                                                                    |
| `managed.paused_reason`             | La raison de la pause. L'une des suivantes : `account_under_review`, `spend_velocity_exceeded`, ou `insufficient_balance`. C'est `null` lorsque le service est `ok`.                                               |
| `managed.binding`                   | Le plafond qui est atteint en premier. L'un des suivants : `balance`, `daily_spend`, `paused`, ou `exempt`.                                                                                                        |
| `managed.spend_remaining_micro_usd` | Le nombre que l'en-tête `x-flexinference-spend-remaining` contient.                                                                                                                                                |
| `managed.balance`                   | `remaining_micro_usd` est la somme des espèces et des crédits. C'est la quantité que nous comparons à zéro. `reserved_micro_usd` est l'argent que vos requêtes en cours retiennent, et nous ne le soustrayons pas. |
| `managed.daily_spend`               | Le plafond, ce qui a été utilisé aujourd'hui, et ce qu'il reste. `resets_at` est le prochain minuit UTC en secondes Unix.                                                                                          |
| `managed.concurrency`               | Combien de requêtes gérées votre organisation exécute simultanément.                                                                                                                                               |
| `managed.ramp_week`                 | La semaine du calendrier d'ancienneté du compte dans laquelle vous vous trouvez. La semaine 0 couvre un compte qui n'a jamais été rechargé.                                                                        |
| `managed.ramp_defaults`             | Ce que cette semaine seule vous donne. Un nombre de concurrence et un plafond quotidien.                                                                                                                           |
| `managed.override_in_force`         | Un indicateur par plafond progressif. `true` signifie qu'un administrateur a défini ce nombre, de sorte que le calendrier hebdomadaire ne le modifiera pas.                                                        |
| `managed.rates`                     | Les limites par minute sur les pools partagés que cette organisation utilise.                                                                                                                                      |
| `abuse_limits`                      | Les limites que toutes les organisations partagent, plus la limite de taille du corps en octets.                                                                                                                   |

Les trois derniers champs expliquent pourquoi votre nombre de concurrence et votre plafond quotidien s'affichent comme ils le font. Une organisation exempte n'a pas de plafond à expliquer, donc les trois affichent `null`.

Un solde en pause signale la suspension au lieu d'un nombre. Aucun chiffre positif ne peut alors être interprété comme une permission d'envoyer.

Ces nombres sont valides à `as_of` et ne promettent rien concernant votre prochaine requête. Une autre requête les modifie, tout comme un règlement, une recharge ou un remboursement.

Une clé manquante ou incorrecte renvoie `401` avec [`invalid_api_key`](/fr/errors#invalid_api_key). Lorsque nous ne pouvons pas lire l'un de ces enregistrements, le point de terminaison renvoie `503` avec [`limits_unavailable`](/fr/errors#limits_unavailable). Il refuse plutôt que de vous donner un chiffre mis en cache, ce qui pourrait revendiquer un espace que votre prochaine requête n'obtiendrait pas. Les requêtes continuent de fonctionner dans les deux cas.

## Coût dans un flux

Une réponse que vous n'avez pas diffusée en continu signale son coût deux fois, dans l'en-tête `x-flexinference-cost` et le bloc `usage.cost`. Une réponse diffusée en continu ne peut pas utiliser l'en-tête, car nous envoyons les en-têtes avant que la réponse n'existe et nous ne connaissons pas le coût à ce moment-là.

Envoyez `include_cost: true` pour déplacer le coût à l'intérieur du flux.

```json theme={null}
{
  "model": "gpt-5.5",
  "start_within": "00h-00m-30s",
  "stream": true,
  "include_cost": true,
  "input": "Summarize this contract."
}
```

Le coût est alors inclus dans le cadre d'utilisation que le point de terminaison envoie déjà. Un bloc `usage.routing` se trouve à côté et nomme la route qui a exécuté la requête.

```json theme={null}
"usage": {
  "input_tokens": 412,
  "output_tokens": 128,
  "cost": { "total_micro_usd": 1840, "currency": "USD" },
  "routing": {
    "provider": "openai",
    "requested_provider": "openai",
    "tier": "flex",
    "reason": "flex_won",
    "fallback_attempts": 0,
    "mode": "byok"
  }
}
```

L'option est désactivée par défaut. Un flux pour lequel vous n'avez pas demandé cela correspond exactement à ce que le fournisseur a envoyé, octet par octet.

`/v1/chat/completions` rend le cadre d'utilisation lui-même optionnel chez OpenAI. Envoyez également `"stream_options": {"include_usage": true}`. Sans cela, le coût n'a pas de cadre où s'insérer.

Une requête gérée signale ce que le fournisseur nous a facturé. Une requête avec vos propres clés signale le prix catalogue du fournisseur au niveau qui l'a exécutée. Une requête que nous ne pouvons pas tarifer ne signale aucun `cost`. Interprétez un bloc manquant comme rien à signaler, et non comme zéro.

Deux en-têtes de routage sont présents sur chaque réponse, quoi qu'il arrive. Ce sont `x-flexinference-served-provider` et `x-flexinference-routing-reason`. Un appelant en streaming qui ignore `include_cost` voit toujours quelle route a exécuté la requête et pourquoi. Voir [lire le résultat](/fr/deadline-routing).

`include_cost` n'atteint jamais le fournisseur. Nous le supprimons du corps avant de transmettre la requête.
