--- title: Budget di sessione url: https://platform.claude.com/docs/it/managed-agents/budgets description: Limita la spesa di una sessione con un budget rigido in dollari applicato alle tariffe di listino pubbliche. 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 di sessione è un tetto di spesa rigido opzionale che imposti quando [crei una sessione](https://platform.claude.com/docs/it/managed-agents/sessions). La piattaforma calcola continuamente il prezzo di tutto ciò che la sessione consuma alle tariffe di listino pubbliche (il **list cost**, o costo di listino, della sessione) e smette di emettere nuove richieste al modello una volta che tale costo raggiunge il budget. La richiesta in corso nel momento in cui il tetto viene superato viene comunque completata, quindi il costo di listino finale può attestarsi [leggermente oltre il budget](https://platform.claude.com/docs/it/managed-agents/budgets#when-a-session-reaches-its-budget). Una sessione che ha raggiunto il proprio budget si mette in pausa e diventa [idle](https://platform.claude.com/docs/it/managed-agents/session-operations#session-statuses) (inattiva) anziché terminare; modificare o rimuovere il budget riprende il lavoro messo in pausa dal budget. I deployment accettano lo stesso budget e lo applicano a ogni sessione che avviano; consulta [Budget sui deployment](https://platform.claude.com/docs/it/managed-agents/budgets#budgets-on-deployments). ## Imposta un budget alla creazione della sessione Passa il campo opzionale `budget` (csharp, go: `Budget`) quando crei la sessione: ```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 # Mantieni l'importo tra virgolette così viene inviato come stringa, non come numero. 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'oggetto `budget` (csharp, go: `Budget`) ha due campi: * `type` (csharp, go: `Type`) è sempre `"limit"`. * `max_list_cost` (java, php: `maxListCost`; csharp, go: `MaxListCost`) è il tetto stesso: `amount` (csharp, go: `Amount`) è un numero intero di centesimi di dollaro USA scritto come stringa senza zeri iniziali (`"125"` corrisponde a $1,25 e `"50"` a 50 centesimi) e deve essere maggiore di zero. Le forme decimali come `"25.00"` vengono rifiutate. L'importo è una stringa anziché un numero, così non gli viene mai applicato alcun arrotondamento in virgola mobile. `currency` (csharp, go: `Currency`) è un codice valuta ISO-4217 in maiuscolo; `USD` è l'unica valuta supportata. Un budget può essere associato solo al momento della creazione della sessione. L'aggiunta di un budget a una sessione esistente che non ne ha uno viene rifiutata con un errore 400. Il tetto di una sessione con budget può essere [modificato](https://platform.claude.com/docs/it/managed-agents/budgets#change-the-budget) o [rimosso](https://platform.claude.com/docs/it/managed-agents/budgets#remove-the-budget) in qualsiasi momento. ## Come viene misurato il costo di listino La piattaforma calcola il prezzo di ciò che la sessione consuma, in modo continuo, alle tariffe di listino pubbliche: * **Token del modello**, al prezzo di listino di ciascun modello servito * **Ricerche web**, a $10 USD per 1.000 ricerche * **Tempo di esecuzione della sessione**, a $0,08 USD all'ora Questo totale progressivo in dollari è il **costo di listino** della sessione, ed è il valore con cui viene confrontato il budget. Il costo di listino non è il tuo prezzo contrattuale: se la tua organizzazione ha negoziato sconti, la sessione raggiunge il proprio tetto quando lo raggiunge il totale a prezzo di listino, e la tua spesa fatturata potrebbe essere inferiore al tetto. L'applicazione del limite utilizza il costo di listino esatto, non arrotondato. I valori `list_cost` (java, php: `listCost`; csharp, go: `ListCost`) riportati sulla sessione e sui suoi eventi sono centesimi interi, arrotondati al centesimo più vicino, quindi un valore riportato può differire fino a mezzo centesimo, in più o in meno, dall'importo esatto utilizzato per l'applicazione del limite. ## Quando una sessione raggiunge il proprio budget Il tetto viene applicato tra una richiesta al modello e l'altra, non a metà di una richiesta. Prima di ogni richiesta al modello, la piattaforma controlla il costo di listino consumato dalla sessione e, una volta che tale totale raggiunge il tetto, ogni thread si mette in pausa prima della richiesta successiva. La richiesta che ha portato il totale oltre il tetto è stata ammessa quando la sessione era ancora al di sotto di esso e viene eseguita fino al completamento, quindi il valore `list_cost` (java, php: `listCost`; csharp, go: `ListCost`) registrato di una sessione in pausa risulta pari o leggermente superiore a `max_list_cost` (java, php: `maxListCost`; csharp, go: `MaxListCost`): una sessione con tetto `"50"` (50 centesimi) può mettersi in pausa con un `list_cost` (java, php: `listCost`; csharp, go: `ListCost`) di `"53"`. Questo comportamento è previsto e non è un errore di fatturazione. La spesa per il modello oltre il tetto è al massimo il costo di una richiesta al modello per ciascun thread. Le chiamate agli strumenti presenti nella risposta a quella richiesta vengono comunque eseguite, e anche le relative ricerche web e il tempo di esecuzione contano ai fini del costo di listino. Considera il budget come un limite al nuovo lavoro piuttosto che come un punto di arresto esatto, e dimensiona il tetto tenendo conto di questo margine. Una sessione che raggiunge il proprio budget diventa inattiva con uno `stop_reason` (java, php: `stopReason`; csharp, go: `StopReason`) pari a `budget_reached`; non viene terminata, e la sua cronologia e la sua sandbox vengono conservate come per qualsiasi altra sessione inattiva. Sul [flusso di eventi](https://platform.claude.com/docs/it/managed-agents/events-and-streaming) vedrai, nell'ordine: 1. Un evento `session.thread_status_idle` con uno `stop_reason` (java, php: `stopReason`; csharp, go: `StopReason`) pari a `budget_reached` man mano che ciascun thread si mette in pausa. 2. Un evento [`session.usage`](https://platform.claude.com/docs/it/managed-agents/budgets#monitor-spend) con l'utilizzo cumulativo e il costo di listino della sessione. 3. Un evento `session.status_idle` con uno `stop_reason` (java, php: `stopReason`; csharp, go: `StopReason`) pari a `budget_reached`. L'evento di utilizzo precede sempre immediatamente questo evento di inattività. Se sono aperte delle [esecuzioni di workflow](https://platform.claude.com/docs/it/managed-agents/workflow-runs#budgets-and-limits), ciascuna che non sia già inattiva riceve anche un evento `workflow_run.status_idle`. Un thread la cui richiesta finale supera il tetto e al contempo completa il proprio turno riporta `end_turn` sul proprio evento `session.thread_status_idle`, mentre la sessione riporta comunque `budget_reached`; considera lo `stop_reason` (java, php: `stopReason`; csharp, go: `StopReason`) a livello di sessione come il segnale che la sessione si è messa in pausa al raggiungimento del budget. ### Eventi accettati al raggiungimento del tetto Mentre la sessione è pari o superiore al proprio budget, accetta solo eventi che concludono il lavoro già in corso: * `user.tool_confirmation` * `user.tool_result` * `user.custom_tool_result` * `user.interrupt` Qualsiasi evento che avvierebbe nuovo lavoro, come `user.message`, viene rifiutato con un errore 400 che elenca questa lista. I risultati conclusi vengono registrati senza attivare una nuova richiesta al modello; la sessione rimane in pausa al proprio budget. Un `user.interrupt` inviato mentre la sessione è in pausa al raggiungimento del budget (tutti i thread in pausa al tetto) viene accettato e non compare nell'elenco degli eventi. Non ferma alcun thread, perché ogni thread è già in pausa. Modifica o rimuovi il budget per continuare. Se la sessione ha [esecuzioni di workflow](https://platform.claude.com/docs/it/managed-agents/workflow-runs#interrupt-a-session-with-runs-open) aperte, l'interruzione può metterle in pausa, come può fare un'interruzione in qualsiasi altro momento. Un'esecuzione messa in pausa da un'interruzione non riprende quando modifichi o rimuovi il budget. Per continuarla, modifica o rimuovi il budget, quindi invia un `user.message` chiedendo all'agente di continuare le sue esecuzioni. ## Riprendi una sessione che ha raggiunto il budget Modifica o rimuovi il budget con un aggiornamento della sessione. Un aggiornamento accettato riprende automaticamente il lavoro messo in pausa dal budget; non è necessaria alcuna ulteriore azione da parte del client. Ogni [esecuzione di workflow](https://platform.claude.com/docs/it/managed-agents/workflow-runs#budgets-and-limits) messa in pausa dal budget riceve anche un evento `workflow_run.status_running`. Un'esecuzione messa in pausa da un'interruzione, anche da un'interruzione inviata mentre la sessione era al proprio budget, rimane in pausa e non riceve alcun evento `workflow_run.status_running` dall'aggiornamento. Per continuarla, invia un `user.message` chiedendo all'agente di continuare le sue esecuzioni. Consulta [Interrompere una sessione con esecuzioni aperte](https://platform.claude.com/docs/it/managed-agents/workflow-runs#interrupt-a-session-with-runs-open). ### Modifica il budget Aggiorna la sessione con un nuovo `max_list_cost` (java, php: `maxListCost`; csharp, go: `MaxListCost`). Il nuovo valore può essere superiore o inferiore al tetto attuale, ma deve essere strettamente maggiore del costo di listino consumato dalla sessione; in caso contrario l'aggiornamento viene rifiutato con un errore 400: `budget.max_list_cost must be greater than the session's consumed list cost`. Poiché il costo consumato di solito si trova [leggermente oltre il vecchio tetto](https://platform.claude.com/docs/it/managed-agents/budgets#when-a-session-reaches-its-budget) quando la sessione si mette in pausa, basa il nuovo valore sul `usage.list_cost` (java, php: `usage.listCost`; csharp, go: `Usage.ListCost`) riportato dalla sessione, non sul vecchio `max_list_cost` (java, php: `maxListCost`; csharp, go: `MaxListCost`). Impostalo almeno un centesimo al di sopra di quel valore: il valore riportato è arrotondato e può trovarsi leggermente al di sotto del costo consumato esatto utilizzato dal controllo. ```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 ``` ### Rimuovi il budget Passa `"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`) per rimuovere completamente il tetto. Il lavoro che il budget aveva messo in pausa riprende, e l'evento `session.updated` risultante riporta `budget` (csharp, go: `Budget`) impostato su `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# // Assegnare null invia un null esplicito; lasciare Budget non impostato ometterebbe il campo. 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 con valore zero viene omesso dalla richiesta; param.NullStruct (da // github.com/anthropics/anthropic-sdk-go/packages/param) invia un null esplicito. 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 vuoto invia un null esplicito; lasciare budget non impostato ometterebbe il campo. 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) omette il campo, quindi invia il null esplicito come parametro extra del body. $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 rimozione del budget di una sessione è irreversibile: a una sessione il cui budget è stato rimosso non può esserne assegnato uno nuovo. Per mantenere un tetto sulla sessione, modifica invece il budget. ## Monitora la spesa L'oggetto sessione riporta il proprio `budget` (csharp, go: `Budget`) e un oggetto `usage` (csharp, go: `Usage`) con la spesa tracciata: `usage.list_cost` (java, php: `usage.listCost`; csharp, go: `Usage.ListCost`) è il costo di listino consumato dalla sessione, e `usage.active_seconds` (java, php: `usage.activeSeconds`; csharp, go: `Usage.ActiveSeconds`) è il tempo di esecuzione su cui viene calcolato il costo di runtime. Su una sessione in pausa con `budget_reached`, aspettati che `usage.list_cost` (java, php: `usage.listCost`; csharp, go: `Usage.ListCost`) risulti pari o leggermente superiore a `max_list_cost` (java, php: `maxListCost`; csharp, go: `MaxListCost`): la [richiesta che ha superato il tetto](https://platform.claude.com/docs/it/managed-agents/budgets#when-a-session-reaches-its-budget) è stata completata prima della pausa. Il valore `active_seconds` (java, php: `activeSeconds`; csharp, go: `ActiveSeconds`) a livello di sessione conta una sola volta l'attività sovrapposta di thread concorrenti. Le risposte di recupero dei thread riportano gli stessi due campi nel `usage` (csharp, go: `Usage`) del thread stesso, con prezzo calcolato per thread. I valori per thread sono arrotondati in modo indipendente ed escludono il costo del tempo di esecuzione della sessione, quindi la loro somma non corrisponde esattamente al `list_cost` (java, php: `listCost`; csharp, go: `ListCost`) della sessione; il valore della sessione è quello rispetto al quale viene applicato il budget. L'evento `session.usage` è un'istantanea dell'utilizzo cumulativo e del costo di listino tracciato della sessione. Riporta i totali dei token della sessione, `list_cost` (java, php: `listCost`; csharp, go: `ListCost`), `active_seconds` (java, php: `activeSeconds`; csharp, go: `ActiveSeconds`), i conteggi delle richieste `server_tool_use` (java, php: `serverToolUse`; csharp, go: `ServerToolUse`) (`web_search_requests` (java, php: `webSearchRequests`; csharp, go: `WebSearchRequests`), il cui prezzo è incluso nel costo di listino per richiesta, e `web_fetch_requests` (java, php: `webFetchRequests`; csharp, go: `WebFetchRequests`), che riporta `0` perché le richieste di web fetch non hanno alcun addebito per richiesta e non vengono misurate), e il `budget` (csharp, go: `Budget`) della sessione, se la sessione ne ha uno. Compare nell'elenco degli eventi e nel flusso della sessione. La sessione ne emette uno immediatamente prima di diventare inattiva, qualunque sia il motivo dell'arresto, quindi una sessione che raggiunge il proprio budget ne emette sempre uno immediatamente prima dell'evento di inattività per budget raggiunto. Per leggere l'utilizzo dal flusso e dall'oggetto sessione, consulta [Monitorare l'utilizzo](https://platform.claude.com/docs/it/managed-agents/session-observability#track-usage). ## Budget nelle sessioni multiagente Una sessione [multiagente](https://platform.claude.com/docs/it/managed-agents/multiagent-orchestration) ha un unico budget condiviso tra tutti i suoi thread; non esistono tetti per thread. Il consumo di ciascun thread viene calcolato in base al proprio modello servito e i thread si mettono in pausa in modo indipendente man mano che il tetto condiviso viene raggiunto. Le consultazioni dell'[advisor](https://platform.claude.com/docs/it/managed-agents/multiagent-orchestration#give-the-session-an-advisor) vengono conteggiate sullo stesso budget, calcolate alle tariffe del modello advisor. Un thread può mettersi in pausa con `budget_reached` mentre un altro completa la propria richiesta in corso. Una richiesta in sospeso ha la precedenza sul tetto: una sessione con un thread in attesa su `requires_action` e un altro in pausa con `budget_reached` riporta `requires_action` a livello di sessione. La richiesta in sospeso necessita comunque di una risposta, e rispondere è un [evento di conclusione](https://platform.claude.com/docs/it/managed-agents/budgets#events-accepted-at-the-cap) che il budget non blocca. ## Budget sui deployment Un [deployment](https://platform.claude.com/docs/it/managed-agents/scheduled-deployments) accetta lo stesso oggetto `budget` quando lo crei o lo aggiorni: ```json { "budget": { "type": "limit", "max_list_cost": { "amount": "2000", "currency": "USD" } } } ``` Il tetto viene copiato su ogni sessione avviata dal deployment, quindi vincola ciascuna esecuzione separatamente anziché la spesa cumulativa del deployment. La modifica del budget del deployment si applica alle sessioni che il deployment avvia successivamente, non alle sessioni già in esecuzione. A differenza di una sessione, il budget di un deployment può essere cancellato con `"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`) e reimpostato in seguito. Consulta [Impostare un budget per ogni esecuzione](https://platform.claude.com/docs/it/managed-agents/scheduled-deployments#set-a-budget-on-each-run). ## Modelli senza prezzo di listino Un budget può tracciare solo il consumo di cui la piattaforma è in grado di calcolare il prezzo. La creazione di una sessione con budget il cui agente, o qualsiasi agente elencato nella lista `predefined_agents` (java, php: `predefinedAgents`; csharp, go: `PredefinedAgents`) di `subagents` (csharp, go: `Subagents`) o `workflows` (csharp, go: `Workflows`), o l'advisor impostato nella sua [configurazione multiagente](https://platform.claude.com/docs/it/managed-agents/multiagent-orchestration), utilizza un modello senza prezzo di listino pubblico viene rifiutata con un errore 400 che indica che non è disponibile alcun prezzo di listino per il modello. Se l'utilizzo di una sessione con budget arriva a includere un modello senza prezzo di listino, il budget non è più in grado di misurare la spesa della sessione: la sessione può mettersi in pausa con uno `stop_reason` (java, php: `stopReason`; csharp, go: `StopReason`) pari a `budget_reached`, e la modifica del budget viene rifiutata. Rimuovi il budget per riprendere la sessione. ## Riferimento errori Le richieste relative al budget vengono rifiutate nei seguenti casi: | Condizione | Stato | | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----- | | Viene inviato un evento che avvia lavoro (ad esempio, `user.message`) mentre la sessione è pari o superiore al proprio budget; l'errore elenca gli [eventi di conclusione accettati](https://platform.claude.com/docs/it/managed-agents/budgets#events-accepted-at-the-cap) | 400 | | Il budget viene impostato su un valore pari o inferiore al costo di listino consumato dalla sessione | 400 | | Viene aggiunto un budget a una sessione creata senza, oppure viene aggiunto nuovamente dopo la rimozione | 400 | | `amount` (csharp, go: `Amount`) non è un numero intero di centesimi (ad esempio, `"25.00"`), è zero o negativo, oppure `currency` (csharp, go: `Currency`) non è `USD` | 400 | | Una creazione con budget fa riferimento a un modello [senza prezzo di listino pubblico](https://platform.claude.com/docs/it/managed-agents/budgets#models-without-a-list-price) | 400 | I budget di sessione sono tetti rigidi in dollari USA (scritti in centesimi) su una singola sessione, applicati dalla piattaforma. Sono distinti dai [task budget](https://platform.claude.com/docs/it/build-with-claude/task-budgets) della Messages API, che sono budget indicativi, denominati in token, che il modello utilizza per autoregolarsi all'interno di un singolo ciclo agentico.