--- title: Orçamentos de sessão url: https://platform.claude.com/docs/pt-BR/managed-agents/budgets description: Limite os gastos de uma sessão com um orçamento rígido em dólares, aplicado com base nas tarifas públicas de lista. featureMetadata: topic: title: Managed Agents url: https://platform.claude.com/docs/en/managed-agents/overview status: beta betaHeader: managed-agents-2026-04-01 --- Um "session budget" (orçamento de sessão) é um teto rígido de gasto opcional que você define ao [criar uma sessão](https://platform.claude.com/docs/pt-BR/managed-agents/sessions). A plataforma precifica continuamente tudo o que a sessão consome às tarifas públicas de lista (o **"list cost"**, ou custo de lista, da sessão) e para de emitir novas requisições ao modelo quando esse custo atinge o orçamento. A requisição em andamento quando o teto é ultrapassado ainda é concluída, portanto o custo de lista final pode ficar [uma fração acima do orçamento](https://platform.claude.com/docs/pt-BR/managed-agents/budgets#when-a-session-reaches-its-budget). Uma sessão que atinge seu orçamento pausa e fica [ociosa](https://platform.claude.com/docs/pt-BR/managed-agents/session-operations#session-statuses) em vez de ser encerrada; alterar ou remover o orçamento retoma o trabalho que o orçamento pausou. Implantações aceitam o mesmo orçamento e o aplicam a cada sessão que iniciam; consulte [Orçamentos em implantações](https://platform.claude.com/docs/pt-BR/managed-agents/budgets#budgets-on-deployments). ## Definir um orçamento na criação da sessão Passe o campo opcional `budget` (csharp, go: `Budget`) ao criar a sessão: ```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 # Mantenha o valor entre aspas para que seja enviado como string, não como número. 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 ``` O objeto `budget` (csharp, go: `Budget`) tem dois campos: * `type` (csharp, go: `Type`) é sempre `"limit"`. * `max_list_cost` (java, php: `maxListCost`; csharp, go: `MaxListCost`) é o teto em si: `amount` (csharp, go: `Amount`) é um número inteiro de centavos de dólar americano escrito como string sem zeros à esquerda (`"125"` equivale a $1,25 e `"50"` equivale a 50 centavos) e deve ser maior que zero. Formas decimais como `"25.00"` são rejeitadas. O valor é uma string em vez de um número para que nenhum arredondamento de ponto flutuante seja aplicado a ele. `currency` (csharp, go: `Currency`) é um código de moeda ISO-4217 em maiúsculas; `USD` é a única moeda suportada. Um orçamento só pode ser anexado quando a sessão é criada. Adicionar um orçamento a uma sessão existente que não tem um é rejeitado com um erro 400. O teto de uma sessão com orçamento pode ser [alterado](https://platform.claude.com/docs/pt-BR/managed-agents/budgets#change-the-budget) ou [removido](https://platform.claude.com/docs/pt-BR/managed-agents/budgets#remove-the-budget) a qualquer momento. ## Como o custo de lista é medido A plataforma precifica o que a sessão consome, continuamente, às tarifas públicas de lista: * **Tokens do modelo**, ao preço de lista de cada modelo servido * **Pesquisas na web**, a $10 USD por 1.000 pesquisas * **Tempo de execução da sessão**, a $0,08 USD por hora Esse total acumulado em dólares é o **custo de lista** da sessão, e é com ele que o orçamento é comparado. O custo de lista não é o seu preço contratado: se sua organização negociou descontos, a sessão atinge seu teto quando o total a preço de lista o atinge, e seu gasto faturado pode ser menor que o teto. A aplicação do teto usa o custo de lista exato, sem arredondamento. Os valores de `list_cost` (java, php: `listCost`; csharp, go: `ListCost`) informados na sessão e em seus eventos são centavos inteiros, arredondados para o centavo mais próximo, então um valor informado pode diferir em até meio centavo, para mais ou para menos, do valor exato usado na aplicação do teto. ## Quando uma sessão atinge seu orçamento O teto é aplicado entre requisições ao modelo, não no meio de uma requisição. Antes de cada requisição ao modelo, a plataforma verifica o custo de lista consumido pela sessão e, assim que esse total atinge o teto, cada thread é pausada antes de sua próxima requisição. A requisição que levou o total além do teto foi admitida enquanto a sessão ainda estava abaixo dele e é executada até o fim, então o `list_cost` (java, php: `listCost`; csharp, go: `ListCost`) registrado de uma sessão pausada fica igual ou uma fração acima de `max_list_cost` (java, php: `maxListCost`; csharp, go: `MaxListCost`): uma sessão com teto de `"50"` (50 centavos) pode ser pausada com um `list_cost` (java, php: `listCost`; csharp, go: `ListCost`) de `"53"`. Isso é esperado, não um erro de cobrança. O gasto com o modelo além do teto é, no máximo, o custo de uma requisição ao modelo para cada thread. As chamadas de ferramentas na resposta dessa requisição ainda são executadas, e suas pesquisas na web e seu tempo de execução também contam para o custo de lista. Trate o orçamento como um limite para novos trabalhos, e não como um ponto de parada exato, e dimensione o teto levando essa margem em consideração. Uma sessão que atinge seu orçamento fica ociosa com um `stop_reason` (java, php: `stopReason`; csharp, go: `StopReason`) de `budget_reached`; ela não é encerrada, e seu histórico e sandbox são preservados como os de qualquer outra sessão ociosa. No [fluxo de eventos](https://platform.claude.com/docs/pt-BR/managed-agents/events-and-streaming) você verá, nesta ordem: 1. Um evento `session.thread_status_idle` com um `stop_reason` (java, php: `stopReason`; csharp, go: `StopReason`) de `budget_reached` à medida que cada thread é pausada. 2. Um evento [`session.usage`](https://platform.claude.com/docs/pt-BR/managed-agents/budgets#monitor-spend) com o uso acumulado e o custo de lista da sessão. 3. Um evento `session.status_idle` com um `stop_reason` (java, php: `stopReason`; csharp, go: `StopReason`) de `budget_reached`. O evento de uso sempre precede imediatamente esse evento de ociosidade. Se houver [execuções de workflow](https://platform.claude.com/docs/pt-BR/managed-agents/workflow-runs#budgets-and-limits) abertas, cada uma que ainda não esteja ociosa também recebe um evento `workflow_run.status_idle`. Uma thread cuja requisição final tanto ultrapassa o teto quanto conclui seu turno informa `end_turn` em seu próprio evento `session.thread_status_idle`, enquanto a sessão ainda informa `budget_reached`; trate o `stop_reason` (java, php: `stopReason`; csharp, go: `StopReason`) no nível da sessão como o sinal de que a sessão foi pausada em seu orçamento. ### Eventos aceitos no teto Enquanto a sessão está no orçamento ou acima dele, ela aceita apenas eventos que resolvem trabalho já em andamento: * `user.tool_confirmation` * `user.tool_result` * `user.custom_tool_result` * `user.interrupt` Qualquer evento que iniciaria novo trabalho, como `user.message`, é rejeitado com um erro 400 que nomeia essa lista. Resultados resolvidos são registrados sem disparar uma nova requisição ao modelo; a sessão permanece pausada em seu orçamento. Um `user.interrupt` enviado enquanto a sessão está pausada em seu orçamento (todas as threads pausadas no teto) é aceito e não aparece na lista de eventos. Ele não para nenhuma thread, porque todas as threads já estão pausadas. Altere ou remova o orçamento para continuar. Se a sessão tiver [execuções de workflow](https://platform.claude.com/docs/pt-BR/managed-agents/workflow-runs#interrupt-a-session-with-runs-open) abertas, a interrupção pode pausá-las, como uma interrupção em qualquer outro momento também pode. Uma execução que uma interrupção pausou não é retomada quando você altera ou remove o orçamento. Para continuá-la, altere ou remova o orçamento e, em seguida, envie uma `user.message` pedindo ao agente que continue suas execuções. ## Retomar uma sessão em seu orçamento Altere ou remova o orçamento com uma atualização da sessão. Uma atualização aceita retoma automaticamente o trabalho que o orçamento pausou; nenhuma ação adicional do cliente é necessária. Cada [execução de workflow](https://platform.claude.com/docs/pt-BR/managed-agents/workflow-runs#budgets-and-limits) que o orçamento pausou também recebe um evento `workflow_run.status_running`. Uma execução que uma interrupção pausou, mesmo uma interrupção enviada enquanto a sessão estava em seu orçamento, permanece pausada e não recebe nenhum evento `workflow_run.status_running` como resultado da atualização. Para continuá-la, envie uma `user.message` pedindo ao agente que continue suas execuções. Consulte [Interromper uma sessão com execuções abertas](https://platform.claude.com/docs/pt-BR/managed-agents/workflow-runs#interrupt-a-session-with-runs-open). ### Alterar o orçamento Atualize a sessão com um novo `max_list_cost` (java, php: `maxListCost`; csharp, go: `MaxListCost`). O novo valor pode ser maior ou menor que o teto atual, mas deve ser estritamente maior que o custo de lista consumido pela sessão; caso contrário, a atualização é rejeitada com um erro 400: `budget.max_list_cost must be greater than the session's consumed list cost`. Como o custo consumido geralmente fica [uma fração acima do teto antigo](https://platform.claude.com/docs/pt-BR/managed-agents/budgets#when-a-session-reaches-its-budget) quando a sessão é pausada, baseie o novo valor no `usage.list_cost` (java, php: `usage.listCost`; csharp, go: `Usage.ListCost`) informado pela sessão, e não no `max_list_cost` (java, php: `maxListCost`; csharp, go: `MaxListCost`) antigo. Defina-o um centavo ou mais acima desse valor: o valor informado é arredondado e pode ficar uma fração abaixo do custo consumido exato que a verificação usa. ```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 ``` ### Remover o orçamento Passe `"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`) para remover o teto completamente. O trabalho que o orçamento pausou é retomado, e o evento `session.updated` resultante traz `budget` (csharp, go: `Budget`) definido como `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# // Atribuir null envia um null explícito; deixar Budget sem definir omitiria o 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 // Um Budget com valor zero é omitido da requisição; param.NullStruct (de // github.com/anthropics/anthropic-sdk-go/packages/param) envia um null explícito. 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 // Um Optional vazio envia um null explícito; deixar budget sem definir omitiria o 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) omite o campo, então envie o null explícito como parâmetro extra do corpo. $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 ``` Remover o orçamento de uma sessão é irreversível: uma sessão cujo orçamento foi removido não pode receber um novo. Para manter um teto na sessão, altere o orçamento em vez de removê-lo. ## Monitorar o gasto O objeto da sessão traz seu `budget` (csharp, go: `Budget`) e um objeto `usage` (csharp, go: `Usage`) com os gastos rastreados: `usage.list_cost` (java, php: `usage.listCost`; csharp, go: `Usage.ListCost`) é o custo de lista consumido pela sessão, e `usage.active_seconds` (java, php: `usage.activeSeconds`; csharp, go: `Usage.ActiveSeconds`) é o tempo de execução sobre o qual seu custo de tempo de execução é precificado. Em uma sessão pausada em `budget_reached`, espere que `usage.list_cost` (java, php: `usage.listCost`; csharp, go: `Usage.ListCost`) fique igual ou uma fração acima de `max_list_cost` (java, php: `maxListCost`; csharp, go: `MaxListCost`): a [requisição que ultrapassou o teto](https://platform.claude.com/docs/pt-BR/managed-agents/budgets#when-a-session-reaches-its-budget) foi concluída antes da pausa. O `active_seconds` (java, php: `activeSeconds`; csharp, go: `ActiveSeconds`) no nível da sessão conta uma única vez a atividade sobreposta de threads concorrentes. As respostas de recuperação de threads trazem os mesmos dois campos no próprio `usage` (csharp, go: `Usage`) da thread, precificados por thread. Os valores por thread são arredondados de forma independente e excluem o custo de tempo de execução da sessão, então não somam exatamente o `list_cost` (java, php: `listCost`; csharp, go: `ListCost`) da sessão; o valor da sessão é aquele com base no qual o orçamento é aplicado. O evento `session.usage` é um snapshot do uso acumulado e do custo de lista rastreado da sessão. Ele traz os totais de tokens da sessão, `list_cost` (java, php: `listCost`; csharp, go: `ListCost`), `active_seconds` (java, php: `activeSeconds`; csharp, go: `ActiveSeconds`), as contagens de requisições de `server_tool_use` (java, php: `serverToolUse`; csharp, go: `ServerToolUse`) (`web_search_requests` (java, php: `webSearchRequests`; csharp, go: `WebSearchRequests`), precificado no custo de lista por requisição, e `web_fetch_requests` (java, php: `webFetchRequests`; csharp, go: `WebFetchRequests`), que mostra `0` porque requisições de web fetch não têm cobrança por requisição e não são medidas) e o `budget` (csharp, go: `Budget`) da sessão, se a sessão tiver um. Ele aparece na lista de eventos e no stream da sessão. A sessão emite um imediatamente antes de ficar ociosa, qualquer que seja o motivo da parada, então uma sessão que atinge seu orçamento sempre emite um imediatamente antes do evento de ociosidade por orçamento atingido. Para ler o uso a partir do stream e do objeto da sessão, consulte [Acompanhar o uso](https://platform.claude.com/docs/pt-BR/managed-agents/session-observability#track-usage). ## Orçamentos em sessões multiagente Uma sessão [multiagente](https://platform.claude.com/docs/pt-BR/managed-agents/multiagent-orchestration) tem um único orçamento compartilhado entre todas as suas threads; não há tetos por thread. O consumo de cada thread é precificado em seu próprio modelo servido, e as threads pausam independentemente à medida que o teto compartilhado é atingido. Consultas ao [advisor](https://platform.claude.com/docs/pt-BR/managed-agents/multiagent-orchestration#give-the-session-an-advisor) contam contra o mesmo orçamento, precificadas às tarifas do modelo advisor. Uma thread pode pausar em `budget_reached` enquanto outra termina sua requisição em andamento. Uma solicitação pendente tem precedência sobre o teto: uma sessão com uma thread aguardando em `requires_action` e outra pausada em `budget_reached` reporta `requires_action` no nível da sessão. A requisição pendente ainda precisa de uma resposta, e respondê-la é um [evento de resolução](https://platform.claude.com/docs/pt-BR/managed-agents/budgets#events-accepted-at-the-cap) que o orçamento não bloqueia. ## Orçamentos em implantações Uma ["deployment"](https://platform.claude.com/docs/pt-BR/managed-agents/scheduled-deployments) (implantação) aceita o mesmo objeto `budget` quando você a cria ou atualiza: ```json { "budget": { "type": "limit", "max_list_cost": { "amount": "2000", "currency": "USD" } } } ``` O teto é copiado para cada sessão que a implantação inicia, então ele limita cada execução separadamente, e não o gasto acumulado da implantação. Alterar o orçamento da implantação se aplica às sessões que a implantação iniciar depois, não às sessões já em execução. Diferentemente de uma sessão, o orçamento de uma implantação pode ser removido com `"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 definido novamente mais tarde. Consulte [Definir um orçamento em cada execução](https://platform.claude.com/docs/pt-BR/managed-agents/scheduled-deployments#set-a-budget-on-each-run). ## Modelos sem preço de lista Um orçamento só pode rastrear o consumo que a plataforma consegue precificar. Criar uma sessão com orçamento cujo agente, ou qualquer agente listado na lista `predefined_agents` (java, php: `predefinedAgents`; csharp, go: `PredefinedAgents`) de `subagents` (csharp, go: `Subagents`) ou `workflows` (csharp, go: `Workflows`), ou o advisor definido em sua [configuração multiagente](https://platform.claude.com/docs/pt-BR/managed-agents/multiagent-orchestration), use um modelo sem preço público de lista é rejeitado com um erro 400 informando que não há preço de lista disponível para o modelo. Se o uso de uma sessão com orçamento passar a incluir um modelo sem preço de lista, o orçamento não consegue mais medir os gastos da sessão: a sessão pode ser pausada com um `stop_reason` (java, php: `stopReason`; csharp, go: `StopReason`) de `budget_reached`, e a alteração do orçamento é rejeitada. Remova o orçamento para retomar a sessão. ## Referência de erros Requisições relacionadas a orçamento são rejeitadas nos seguintes casos: | Condição | Status | | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------ | | Um evento que inicia trabalho (por exemplo, `user.message`) é enviado enquanto a sessão está no orçamento ou acima dele; o erro nomeia os [eventos de resolução aceitos](https://platform.claude.com/docs/pt-BR/managed-agents/budgets#events-accepted-at-the-cap) | 400 | | O orçamento é definido com um valor igual ou inferior ao custo de lista consumido pela sessão | 400 | | Um orçamento é adicionado a uma sessão criada sem um, ou readicionado após a remoção | 400 | | `amount` (csharp, go: `Amount`) não é um número inteiro de centavos (por exemplo, `"25.00"`), é zero ou negativo, ou `currency` (csharp, go: `Currency`) não é `USD` | 400 | | Uma criação com orçamento referencia um modelo [sem preço público de lista](https://platform.claude.com/docs/pt-BR/managed-agents/budgets#models-without-a-list-price) | 400 | Orçamentos de sessão são tetos rígidos em dólares americanos (escritos em centavos) sobre uma única sessão, aplicados pela plataforma. Eles são distintos dos [orçamentos de tarefa](https://platform.claude.com/docs/pt-BR/build-with-claude/task-budgets) da Messages API, que são orçamentos consultivos, denominados em tokens, que o modelo usa para se autorregular dentro de um único loop agêntico.