---
title: Budgets de session
url: https://platform.claude.com/docs/fr/managed-agents/budgets
description: Plafonnez les dépenses d'une session avec un budget strict en dollars, appliqué aux tarifs publics.
featureMetadata:
topic:
title: Managed Agents
url: https://platform.claude.com/docs/en/managed-agents/overview
status: beta
betaHeader: managed-agents-2026-04-01
---
Un budget de session est un plafond de dépenses strict et facultatif que vous définissez lorsque vous [créez une session](https://platform.claude.com/docs/fr/managed-agents/sessions). La plateforme évalue en continu tout ce que la session consomme aux tarifs publics (le **coût au tarif public**, ou « list cost », de la session) et cesse d'émettre de nouvelles requêtes au modèle dès que ce coût atteint le budget. La requête en cours au moment où le plafond est franchi se termine tout de même, de sorte que le coût au tarif public final peut se situer [légèrement au-delà du budget](https://platform.claude.com/docs/fr/managed-agents/budgets#when-a-session-reaches-its-budget). Une session ayant atteint son budget se met en pause et passe à l'état [idle](https://platform.claude.com/docs/fr/managed-agents/session-operations#session-statuses) (inactif) au lieu de se terminer ; modifier ou supprimer le budget reprend le travail mis en pause par le budget. Les déploiements acceptent le même budget et l'appliquent à chaque session qu'ils démarrent ; consultez [Budgets sur les déploiements](https://platform.claude.com/docs/fr/managed-agents/budgets#budgets-on-deployments).
## Définir un budget à la création de la session
Transmettez le champ facultatif `budget` (csharp, go: `Budget`) lorsque vous créez la session :
```bash cURL
curl -sS --fail-with-body https://api.anthropic.com/v1/sessions \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-beta: managed-agents-2026-04-01" \
-H "content-type: application/json" \
-d '{
"agent": "'"$AGENT_ID"'",
"environment_id": "'"$ENVIRONMENT_ID"'",
"budget": {
"type": "limit",
"max_list_cost": {"amount": "125", "currency": "USD"}
}
}'
```
```bash CLI
# Gardez le montant entre guillemets pour qu'il soit envoyé comme chaîne, et non comme nombre.
ant beta:sessions create \
--agent "$AGENT_ID" \
--environment-id "$ENVIRONMENT_ID" \
--budget '{type: limit, max_list_cost: {amount: "125", currency: USD}}'
```
```python Python
session = client.beta.sessions.create(
agent=agent.id,
environment_id=environment.id,
budget={
"type": "limit",
"max_list_cost": {"amount": "125", "currency": "USD"},
},
)
print(session.id, session.budget.max_list_cost.amount) # sesn_01... 125
```
```typescript TypeScript
const session = await client.beta.sessions.create({
agent: agent.id,
environment_id: environment.id,
budget: {
type: "limit",
max_list_cost: { amount: "125", currency: "USD" }
}
});
console.log(session.id, session.budget?.max_list_cost.amount); // sesn_01... 125
```
```csharp C#
var session = await client.Beta.Sessions.Create(new()
{
Agent = agent.ID,
EnvironmentID = environment.ID,
Budget = new()
{
Type = BetaManagedAgentsBudgetLimitType.Limit,
MaxListCost = new() { Amount = "125", Currency = BetaCurrency.Usd },
},
});
Console.WriteLine($"{session.ID} {session.Budget?.MaxListCost.Amount}"); // sesn_01... 125
```
```go Go
session, err := client.Beta.Sessions.New(ctx, anthropic.BetaSessionNewParams{
Agent: anthropic.BetaSessionNewParamsAgentUnion{
OfString: anthropic.String(agent.ID),
},
EnvironmentID: environment.ID,
Budget: anthropic.BetaManagedAgentsBudgetLimitParam{
Type: anthropic.BetaManagedAgentsBudgetLimitTypeLimit,
MaxListCost: anthropic.BetaMonetaryAmountParam{
Amount: "125",
Currency: anthropic.BetaCurrencyUsd,
},
},
})
if err != nil {
panic(err)
}
fmt.Println(session.ID, session.Budget.MaxListCost.Amount) // sesn_01... 125
```
```java Java
var session = client.beta().sessions().create(SessionCreateParams.builder()
.agent(agent.id())
.environmentId(environment.id())
.budget(BetaManagedAgentsBudgetLimit.builder()
.type(BetaManagedAgentsBudgetLimit.Type.LIMIT)
.maxListCost(BetaMonetaryAmount.builder()
.amount("125")
.currency(BetaCurrency.USD)
.build())
.build())
.build());
IO.println(session.id() + " " + session.budget().orElseThrow().maxListCost().amount()); // sesn_01... 125
```
```php PHP
$session = $client->beta->sessions->create(
agent: $agent->id,
environmentID: $environment->id,
budget: [
'type' => 'limit',
'max_list_cost' => ['amount' => '125', 'currency' => 'USD'],
],
);
echo "{$session->id} {$session->budget->maxListCost->amount}\n"; // sesn_01... 125
```
```ruby Ruby
session = client.beta.sessions.create(
agent: agent.id,
environment_id: environment.id,
budget: {
type: "limit",
max_list_cost: {amount: "125", currency: "USD"}
}
)
puts "#{session.id} #{session.budget.max_list_cost.amount}" # sesn_01... 125
```
L'objet `budget` (csharp, go: `Budget`) comporte deux champs :
* `type` (csharp, go: `Type`) vaut toujours `"limit"`.
* `max_list_cost` (java, php: `maxListCost`; csharp, go: `MaxListCost`) est le plafond lui-même : `amount` (csharp, go: `Amount`) est un nombre entier de cents américains écrit sous forme de chaîne sans zéros initiaux (`"125"` correspond à 1,25 $ et `"50"` à 50 cents) et doit être supérieur à zéro. Les formes décimales telles que `"25.00"` sont rejetées. Le montant est une chaîne plutôt qu'un nombre afin qu'aucun arrondi en virgule flottante ne lui soit jamais appliqué. `currency` (csharp, go: `Currency`) est un code de devise ISO-4217 en majuscules ; `USD` est la seule devise prise en charge.
Un budget ne peut être attaché qu'au moment de la création de la session. L'ajout d'un budget à une session existante qui n'en possède pas est rejeté avec une erreur 400. Le plafond d'une session dotée d'un budget peut être [modifié](https://platform.claude.com/docs/fr/managed-agents/budgets#change-the-budget) ou [supprimé](https://platform.claude.com/docs/fr/managed-agents/budgets#remove-the-budget) à tout moment.
## Comment le coût au tarif public est mesuré
La plateforme évalue ce que la session consomme, en continu, aux tarifs publics :
* **Les tokens du modèle**, au tarif public de chaque modèle servi
* **Les recherches web**, à 10 $ USD pour 1 000 recherches
* **Le temps d'exécution de la session**, à 0,08 $ USD par heure
Ce total cumulé en dollars constitue le **coût au tarif public** de la session, et c'est à lui que le budget est comparé. Le coût au tarif public n'est pas votre prix contractuel : si votre organisation a négocié des remises, la session atteint son plafond lorsque le total au tarif public l'atteint, et vos dépenses facturées peuvent être inférieures au plafond.
L'application du plafond utilise le coût au tarif public exact, non arrondi. Les valeurs `list_cost` (java, php: `listCost`; csharp, go: `ListCost`) indiquées sur la session et ses événements sont exprimées en cents entiers, arrondies au cent le plus proche, de sorte qu'une valeur indiquée peut s'écarter d'un demi-cent au plus, dans un sens ou dans l'autre, du montant exact utilisé pour l'application du plafond.
## Lorsqu'une session atteint son budget
Le plafond est appliqué entre les requêtes au modèle, et non au milieu d'une requête. Avant chaque requête au modèle, la plateforme vérifie le coût au tarif public consommé par la session, et dès que ce total atteint le plafond, chaque thread se met en pause avant sa requête suivante. La requête qui a fait passer le total au-delà du plafond a été admise alors que la session était encore en dessous et s'exécute jusqu'à son terme, de sorte que la valeur `list_cost` (java, php: `listCost`; csharp, go: `ListCost`) enregistrée d'une session en pause est égale ou légèrement supérieure à `max_list_cost` (java, php: `maxListCost`; csharp, go: `MaxListCost`) : une session plafonnée à `"50"` (50 cents) peut se mettre en pause avec un `list_cost` (java, php: `listCost`; csharp, go: `ListCost`) de `"53"`. Ce comportement est attendu et ne constitue pas une erreur de facturation. Les dépenses liées au modèle au-delà du plafond correspondent au plus au coût d'une requête au modèle pour chaque thread. Les appels d'outils contenus dans la réponse à cette requête s'exécutent tout de même, et leurs recherches web ainsi que leur temps d'exécution sont également comptabilisés dans le coût au tarif public. Considérez le budget comme une limite sur le nouveau travail plutôt que comme un point d'arrêt exact, et dimensionnez le plafond en tenant compte de cette marge.
Une session qui atteint son budget passe à l'état inactif avec un `stop_reason` (java, php: `stopReason`; csharp, go: `StopReason`) de `budget_reached` ; elle n'est pas terminée, et son historique ainsi que son sandbox sont conservés comme pour toute autre session inactive. Sur le [flux d'événements](https://platform.claude.com/docs/fr/managed-agents/events-and-streaming), vous verrez, dans l'ordre :
1. Un événement `session.thread_status_idle` avec un `stop_reason` (java, php: `stopReason`; csharp, go: `StopReason`) de `budget_reached` à mesure que chaque thread se met en pause.
2. Un événement [`session.usage`](https://platform.claude.com/docs/fr/managed-agents/budgets#monitor-spend) avec l'utilisation cumulée et le coût au tarif public de la session.
3. Un événement `session.status_idle` avec un `stop_reason` (java, php: `stopReason`; csharp, go: `StopReason`) de `budget_reached`. L'événement d'utilisation précède toujours immédiatement cet événement d'inactivité.
Si des [exécutions de workflow](https://platform.claude.com/docs/fr/managed-agents/workflow-runs#budgets-and-limits) sont ouvertes, chacune d'elles qui n'est pas déjà inactive reçoit également un événement `workflow_run.status_idle`.
Un thread dont la dernière requête à la fois franchit le plafond et termine son tour indique `end_turn` sur son propre événement `session.thread_status_idle`, tandis que la session indique toujours `budget_reached` ; considérez le `stop_reason` (java, php: `stopReason`; csharp, go: `StopReason`) au niveau de la session comme le signal indiquant que la session s'est mise en pause à son budget.
### Événements acceptés au plafond
Tant que la session est à son budget ou au-delà, elle n'accepte que les événements qui règlent un travail déjà en cours :
* `user.tool_confirmation`
* `user.tool_result`
* `user.custom_tool_result`
* `user.interrupt`
Tout événement qui démarrerait un nouveau travail, tel que `user.message`, est rejeté avec une erreur 400 mentionnant cette liste. Les résultats réglés sont enregistrés sans déclencher de nouvelle requête au modèle ; la session reste en pause à son budget.
Un `user.interrupt` envoyé alors que la session est en pause à son budget (tous les fils en pause au plafond) est accepté, et il n'apparaît pas dans la liste des événements. Il n'arrête aucun fil, car chaque fil est déjà en pause. Modifiez ou supprimez le budget pour continuer.
Si la session a des [exécutions de workflow](https://platform.claude.com/docs/fr/managed-agents/workflow-runs#interrupt-a-session-with-runs-open) ouvertes, l'interruption peut les mettre en pause, comme peut le faire une interruption à tout autre moment. Une exécution mise en pause par une interruption ne reprend pas lorsque vous modifiez ou supprimez le budget. Pour la poursuivre, modifiez ou supprimez le budget, puis envoyez un `user.message` demandant à l'agent de poursuivre ses exécutions.
## Reprendre une session ayant atteint son budget
Modifiez ou supprimez le budget au moyen d'une mise à jour de la session. Une mise à jour acceptée reprend automatiquement le travail mis en pause par le budget ; aucune autre action du client n'est nécessaire.
Chaque [exécution de workflow](https://platform.claude.com/docs/fr/managed-agents/workflow-runs#budgets-and-limits) mise en pause par le budget reçoit également un événement `workflow_run.status_running`. Une exécution mise en pause par une interruption, même une interruption envoyée alors que la session était à son budget, reste en pause et ne reçoit aucun événement `workflow_run.status_running` du fait de la mise à jour. Pour la poursuivre, envoyez un `user.message` demandant à l'agent de poursuivre ses exécutions. Consultez [Interrompre une session avec des exécutions ouvertes](https://platform.claude.com/docs/fr/managed-agents/workflow-runs#interrupt-a-session-with-runs-open).
### Modifier le budget
Mettez à jour la session avec un nouveau `max_list_cost` (java, php: `maxListCost`; csharp, go: `MaxListCost`). La nouvelle valeur peut être supérieure ou inférieure au plafond actuel, mais elle doit être strictement supérieure au coût au tarif public consommé par la session ; sinon, la mise à jour est rejetée avec une erreur 400 : `budget.max_list_cost must be greater than the session's consumed list cost`. Comme le coût consommé se situe généralement [légèrement au-delà de l'ancien plafond](https://platform.claude.com/docs/fr/managed-agents/budgets#when-a-session-reaches-its-budget) lorsque la session se met en pause, basez la nouvelle valeur sur le `usage.list_cost` (java, php: `usage.listCost`; csharp, go: `Usage.ListCost`) indiqué pour la session, et non sur l'ancien `max_list_cost` (java, php: `maxListCost`; csharp, go: `MaxListCost`). Définissez-la au moins un cent au-dessus de cette valeur : la valeur indiquée est arrondie et peut se situer légèrement en dessous du coût consommé exact utilisé par la vérification.
```bash cURL
curl -sS --fail-with-body "https://api.anthropic.com/v1/sessions/$SESSION_ID" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-beta: managed-agents-2026-04-01" \
-H "content-type: application/json" \
-d '{
"budget": {
"type": "limit",
"max_list_cost": {"amount": "500", "currency": "USD"}
}
}'
```
```bash CLI
ant beta:sessions update \
--session-id "$SESSION_ID" \
--budget '{type: limit, max_list_cost: {amount: "500", currency: USD}}'
```
```python Python
updated_session = client.beta.sessions.update(
session.id,
budget={
"type": "limit",
"max_list_cost": {"amount": "500", "currency": "USD"},
},
)
print(updated_session.budget.max_list_cost.amount) # 500
```
```typescript TypeScript
const updatedSession = await client.beta.sessions.update(session.id, {
budget: {
type: "limit",
max_list_cost: { amount: "500", currency: "USD" }
}
});
console.log(updatedSession.budget?.max_list_cost.amount); // 500
```
```csharp C#
var updatedSession = await client.Beta.Sessions.Update(session.ID, new()
{
Budget = new()
{
Type = BetaManagedAgentsBudgetLimitType.Limit,
MaxListCost = new() { Amount = "500", Currency = BetaCurrency.Usd },
},
});
Console.WriteLine(updatedSession.Budget?.MaxListCost.Amount); // 500
```
```go Go
updatedSession, err := client.Beta.Sessions.Update(ctx, session.ID, anthropic.BetaSessionUpdateParams{
Budget: anthropic.BetaManagedAgentsBudgetLimitParam{
Type: anthropic.BetaManagedAgentsBudgetLimitTypeLimit,
MaxListCost: anthropic.BetaMonetaryAmountParam{
Amount: "500",
Currency: anthropic.BetaCurrencyUsd,
},
},
})
if err != nil {
panic(err)
}
fmt.Println(updatedSession.Budget.MaxListCost.Amount) // 500
```
```java Java
var updatedSession = client.beta().sessions().update(session.id(), SessionUpdateParams.builder()
.budget(BetaManagedAgentsBudgetLimit.builder()
.type(BetaManagedAgentsBudgetLimit.Type.LIMIT)
.maxListCost(BetaMonetaryAmount.builder()
.amount("500")
.currency(BetaCurrency.USD)
.build())
.build())
.build());
IO.println(updatedSession.budget().orElseThrow().maxListCost().amount()); // 500
```
```php PHP
$updatedSession = $client->beta->sessions->update(
$session->id,
budget: [
'type' => 'limit',
'max_list_cost' => ['amount' => '500', 'currency' => 'USD'],
],
);
echo "{$updatedSession->budget->maxListCost->amount}\n"; // 500
```
```ruby Ruby
updated_session = client.beta.sessions.update(
session.id,
budget: {
type: "limit",
max_list_cost: {amount: "500", currency: "USD"}
}
)
puts updated_session.budget.max_list_cost.amount # 500
```
### Supprimer le budget
Transmettez `"budget": null` (python: `budget=None`; typescript: `budget: null`; ruby: `budget: nil`; go: `Budget: param.NullStruct[anthropic.BetaManagedAgentsBudgetLimitParam]()`; java: `.budget(Optional.empty())`; csharp: `Budget = null`; php: `requestOptions: ['extraBodyParams' => ['budget' => null]]`; cli: `--budget null`) pour supprimer entièrement le plafond. Le travail que le budget avait mis en pause reprend, et l'événement `session.updated` qui en résulte contient `budget` (csharp, go: `Budget`) défini sur `null`.
```bash cURL
curl -sS --fail-with-body "https://api.anthropic.com/v1/sessions/$SESSION_ID" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-beta: managed-agents-2026-04-01" \
-H "content-type: application/json" \
-d '{"budget": null}'
```
```bash CLI
ant beta:sessions update --session-id "$SESSION_ID" --budget null
```
```python Python
unbudgeted_session = client.beta.sessions.update(session.id, budget=None)
print(unbudgeted_session.budget) # None
```
```typescript TypeScript
const unbudgetedSession = await client.beta.sessions.update(session.id, { budget: null });
console.log(unbudgetedSession.budget); // null
```
```csharp C#
// Affecter null envoie un null explicite ; laisser Budget non défini omettrait le champ.
var unbudgetedSession = await client.Beta.Sessions.Update(session.ID, new() { Budget = null });
Console.WriteLine(unbudgetedSession.Budget is null); // True: the session no longer has a budget
```
```go Go
// Un Budget de valeur nulle est omis de la requête ; param.NullStruct (de
// github.com/anthropics/anthropic-sdk-go/packages/param) envoie un null explicite.
unbudgetedSession, err := client.Beta.Sessions.Update(ctx, session.ID, anthropic.BetaSessionUpdateParams{
Budget: param.NullStruct[anthropic.BetaManagedAgentsBudgetLimitParam](),
})
if err != nil {
panic(err)
}
fmt.Println(unbudgetedSession.JSON.Budget.Valid()) // false: the session no longer has a budget
```
```java Java
// Un Optional vide envoie un null explicite ; ne pas définir budget omettrait le champ.
var unbudgetedSession = client.beta().sessions().update(session.id(), SessionUpdateParams.builder()
.budget(Optional.empty())
.build());
IO.println(unbudgetedSession.budget().isPresent()); // false: the session no longer has a budget
```
```php PHP
// update(budget: null) omet le champ, donc envoyez le null explicite comme paramètre de corps supplémentaire.
$unbudgetedSession = $client->beta->sessions->update(
$session->id,
requestOptions: ['extraBodyParams' => ['budget' => null]],
);
echo json_encode($unbudgetedSession->budget), "\n"; // null
```
```ruby Ruby
unbudgeted_session = client.beta.sessions.update(session.id, budget: nil)
p unbudgeted_session.budget # nil
```
La suppression du budget d'une session est irréversible : une session dont le budget a été supprimé ne peut pas en recevoir un nouveau. Pour conserver un plafond sur la session, modifiez plutôt le budget.
## Surveiller les dépenses
L'objet session contient son `budget` (csharp, go: `Budget`) et un objet `usage` (csharp, go: `Usage`) avec les dépenses suivies : `usage.list_cost` (java, php: `usage.listCost`; csharp, go: `Usage.ListCost`) est le coût au tarif public consommé par la session, et `usage.active_seconds` (java, php: `usage.activeSeconds`; csharp, go: `Usage.ActiveSeconds`) est le temps d'exécution sur lequel son coût d'exécution est calculé. Sur une session en pause à `budget_reached`, attendez-vous à ce que `usage.list_cost` (java, php: `usage.listCost`; csharp, go: `Usage.ListCost`) soit égal ou légèrement supérieur à `max_list_cost` (java, php: `maxListCost`; csharp, go: `MaxListCost`) : la [requête qui a franchi le plafond](https://platform.claude.com/docs/fr/managed-agents/budgets#when-a-session-reaches-its-budget) s'est terminée avant la pause. Le `active_seconds` (java, php: `activeSeconds`; csharp, go: `ActiveSeconds`) au niveau de la session ne compte qu'une seule fois l'activité simultanée de threads concurrents. Les réponses de récupération de thread contiennent les deux mêmes champs dans le `usage` (csharp, go: `Usage`) propre au thread, calculés par thread. Les valeurs par thread sont arrondies indépendamment et excluent le coût du temps d'exécution de la session ; leur somme ne correspond donc pas exactement au `list_cost` (java, php: `listCost`; csharp, go: `ListCost`) de la session ; c'est la valeur de la session qui sert de référence pour l'application du budget.
L'événement `session.usage` est un instantané de l'utilisation cumulée et du coût au tarif public suivi de la session. Il contient les totaux de tokens de la session, `list_cost` (java, php: `listCost`; csharp, go: `ListCost`), `active_seconds` (java, php: `activeSeconds`; csharp, go: `ActiveSeconds`), les nombres de requêtes `server_tool_use` (java, php: `serverToolUse`; csharp, go: `ServerToolUse`) (`web_search_requests` (java, php: `webSearchRequests`; csharp, go: `WebSearchRequests`), intégré au coût au tarif public par requête, et `web_fetch_requests` (java, php: `webFetchRequests`; csharp, go: `WebFetchRequests`), qui vaut `0` car les requêtes de récupération web n'entraînent aucun frais par requête et ne sont pas mesurées), ainsi que le `budget` (csharp, go: `Budget`) de la session si celle-ci en possède un. Il apparaît dans la liste des événements et dans le flux de la session. La session en émet un immédiatement avant de passer à l'état inactif, quelle que soit la raison d'arrêt, de sorte qu'une session qui atteint son budget en émet toujours un immédiatement avant l'événement d'inactivité lié à l'atteinte du budget.
Pour lire l'utilisation à partir du flux et de l'objet session, consultez [Suivre l'utilisation](https://platform.claude.com/docs/fr/managed-agents/session-observability#track-usage).
## Budgets dans les sessions multi-agents
Une session [multi-agents](https://platform.claude.com/docs/fr/managed-agents/multiagent-orchestration) dispose d'un budget unique partagé entre tous ses threads ; il n'existe pas de plafonds par thread. La consommation de chaque thread est évaluée au tarif de son propre modèle servi, et les threads se mettent en pause indépendamment à mesure que le plafond partagé est atteint. Les consultations du [conseiller](https://platform.claude.com/docs/fr/managed-agents/multiagent-orchestration#give-the-session-an-advisor) sont imputées au même budget, évaluées aux tarifs du modèle conseiller. Un thread peut se mettre en pause à `budget_reached` pendant qu'un autre termine sa requête en cours.
Une demande en attente prime sur le plafond : une session dont un thread attend sur `requires_action` et un autre est en pause à `budget_reached` indique `requires_action` au niveau de la session. La demande en attente nécessite toujours une réponse, et y répondre constitue un [événement de règlement](https://platform.claude.com/docs/fr/managed-agents/budgets#events-accepted-at-the-cap) que le budget ne bloque pas.
## Budgets sur les déploiements
Un [déploiement](https://platform.claude.com/docs/fr/managed-agents/scheduled-deployments) accepte le même objet `budget` lorsque vous le créez ou le mettez à jour :
```json
{
"budget": {
"type": "limit",
"max_list_cost": { "amount": "2000", "currency": "USD" }
}
}
```
Le plafond est copié sur chaque session que le déploiement démarre ; il limite donc chaque exécution séparément plutôt que les dépenses cumulées du déploiement. La modification du budget du déploiement s'applique aux sessions que le déploiement démarre ensuite, et non aux sessions déjà en cours d'exécution. Contrairement à une session, le budget d'un déploiement peut être effacé avec `"budget": null` (python: `budget=None`; typescript: `budget: null`; ruby: `budget: nil`; go: `Budget: param.NullStruct[anthropic.BetaManagedAgentsBudgetLimitParam]()`; java: `.budget(Optional.empty())`; csharp: `Budget = null`; php: `requestOptions: ['extraBodyParams' => ['budget' => null]]`; cli: `--budget null`) puis redéfini ultérieurement. Consultez [Définir un budget pour chaque exécution](https://platform.claude.com/docs/fr/managed-agents/scheduled-deployments#set-a-budget-on-each-run).
## Modèles sans tarif public
Un budget ne peut suivre que la consommation que la plateforme est en mesure de tarifer. La création d'une session dotée d'un budget dont l'agent, ou tout agent figurant dans la liste `predefined_agents` (java, php: `predefinedAgents`; csharp, go: `PredefinedAgents`) de `subagents` (csharp, go: `Subagents`) ou de `workflows` (csharp, go: `Workflows`), ou le conseiller défini dans sa [configuration multi-agents](https://platform.claude.com/docs/fr/managed-agents/multiagent-orchestration), utilise un modèle sans tarif public est rejetée avec une erreur 400 indiquant qu'aucun tarif public n'est disponible pour le modèle.
Si l'utilisation d'une session dotée d'un budget en vient à inclure un modèle sans tarif public, le budget ne peut plus mesurer les dépenses de la session : la session peut se mettre en pause avec un `stop_reason` (java, php: `stopReason`; csharp, go: `StopReason`) de `budget_reached`, et la modification du budget est rejetée. Supprimez le budget pour reprendre la session.
## Référence des erreurs
Les requêtes liées au budget sont rejetées dans les cas suivants :
| Condition | Statut |
| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------ |
| Un événement démarrant un travail (par exemple, `user.message`) est envoyé alors que la session est à son budget ou au-delà ; l'erreur mentionne les [événements de règlement acceptés](https://platform.claude.com/docs/fr/managed-agents/budgets#events-accepted-at-the-cap) | 400 |
| Le budget est défini sur une valeur égale ou inférieure au coût au tarif public consommé par la session | 400 |
| Un budget est ajouté à une session créée sans budget, ou ajouté de nouveau après suppression | 400 |
| `amount` (csharp, go: `Amount`) n'est pas un nombre entier de cents (par exemple, `"25.00"`), est nul ou négatif, ou `currency` (csharp, go: `Currency`) n'est pas `USD` | 400 |
| Une création avec budget référence un modèle [sans tarif public](https://platform.claude.com/docs/fr/managed-agents/budgets#models-without-a-list-price) | 400 |
Les budgets de session sont des plafonds stricts en dollars américains (écrits en cents) sur une seule session, appliqués par la plateforme. Ils sont distincts des [budgets de tâche](https://platform.claude.com/docs/fr/build-with-claude/task-budgets) de l'API Messages, qui sont des budgets indicatifs, exprimés en tokens, que le modèle utilise pour s'autoréguler au sein d'une boucle agentique.