---
title: Бюджеты сессий
url: https://platform.claude.com/docs/ru/managed-agents/budgets
description: Ограничьте расходы сессии жёстким бюджетом в долларах, который применяется по публичным прейскурантным ценам.
featureMetadata:
topic:
title: Managed Agents
url: https://platform.claude.com/docs/en/managed-agents/overview
status: beta
betaHeader: managed-agents-2026-04-01
---
«Session budget» (бюджет сессии) — это необязательный жёсткий потолок расходов, который вы задаёте при [создании сессии](https://platform.claude.com/docs/ru/managed-agents/sessions). Платформа непрерывно оценивает всё, что потребляет сессия, по публичным прейскурантным ценам. Эта сумма называется **list cost** (прейскурантная стоимость) сессии. Как только стоимость достигает бюджета, платформа прекращает отправлять новые запросы к модели. Запрос, который выполняется в момент превышения лимита, всё равно завершается, поэтому итоговая прейскурантная стоимость может [немного превысить бюджет](https://platform.claude.com/docs/ru/managed-agents/budgets#when-a-session-reaches-its-budget). Сессия, достигшая бюджета, не завершается, а приостанавливается и переходит в состояние [«idle» (ожидание)](https://platform.claude.com/docs/ru/managed-agents/session-operations#session-statuses). Если изменить или удалить бюджет, возобновится работа, приостановленная бюджетом. Развёртывания принимают такой же бюджет и применяют его к каждой запускаемой ими сессии; см. [Бюджеты в развёртываниях](https://platform.claude.com/docs/ru/managed-agents/budgets#budgets-on-deployments).
## Задание бюджета при создании сессии
Передайте необязательное поле `budget` (csharp, go: `Budget`) при создании сессии:
```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
# Оставьте сумму в кавычках, чтобы она отправлялась как строка, а не число.
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
```
Объект `budget` (csharp, go: `Budget`) содержит два поля:
* `type` (csharp, go: `Type`) всегда равно `"limit"`.
* `max_list_cost` (java, php: `maxListCost`; csharp, go: `MaxListCost`) — это сам лимит: `amount` (csharp, go: `Amount`) — целое число центов США, записанное строкой без ведущих нулей (`"125"` — это $1,25, а `"50"` — 50 центов), и оно должно быть больше нуля. Десятичные формы, такие как `"25.00"`, отклоняются. Сумма задаётся строкой, а не числом, чтобы к ней никогда не применялось округление чисел с плавающей точкой. `currency` (csharp, go: `Currency`) — код валюты ISO-4217 в верхнем регистре; `USD` — единственная поддерживаемая валюта.
Бюджет можно прикрепить только при создании сессии. Попытка добавить бюджет к существующей сессии без бюджета отклоняется с ошибкой 400. Лимит сессии с бюджетом можно [изменить](https://platform.claude.com/docs/ru/managed-agents/budgets#change-the-budget) или [удалить](https://platform.claude.com/docs/ru/managed-agents/budgets#remove-the-budget) в любое время.
## Как измеряется прейскурантная стоимость
Платформа непрерывно оценивает то, что потребляет сессия, по публичным прейскурантным тарифам:
* **Токены модели** — по прейскурантной цене каждой обслуживающей модели
* **Веб-поиски** — по $10 USD за 1 000 поисков
* **Время работы сессии** — по $0,08 USD в час
Эта нарастающая сумма в долларах и есть **прейскурантная стоимость** сессии, и именно с ней сравнивается бюджет. Прейскурантная стоимость — это не ваша договорная цена: если ваша организация согласовала скидки, сессия достигает лимита тогда, когда его достигает сумма по прейскурантным ценам, и ваши фактически выставленные расходы могут быть ниже лимита.
Для применения лимита используется точная, неокруглённая прейскурантная стоимость. Значения `list_cost` (java, php: `listCost`; csharp, go: `ListCost`), сообщаемые в сессии и её событиях, выражены в целых центах и округлены до ближайшего цента, поэтому сообщаемое значение может отличаться до половины цента в любую сторону от точной суммы, используемой при применении лимита.
## Когда сессия достигает бюджета
Лимит применяется между запросами к модели, а не посреди запроса. Перед каждым запросом к модели платформа проверяет потреблённую прейскурантную стоимость сессии, и как только эта сумма достигает лимита, каждый поток приостанавливается перед своим следующим запросом. Запрос, из-за которого сумма превысила лимит, был допущен, пока сессия ещё была ниже лимита, и выполняется до конца, поэтому записанное значение `list_cost` (java, php: `listCost`; csharp, go: `ListCost`) приостановленной сессии равно `max_list_cost` (java, php: `maxListCost`; csharp, go: `MaxListCost`) или немного превышает его: сессия с лимитом `"50"` (50 центов) может приостановиться со значением `list_cost` (java, php: `listCost`; csharp, go: `ListCost`), равным `"53"`. Это ожидаемое поведение, а не ошибка выставления счетов. Расходы на модель сверх лимита составляют не более стоимости одного запроса к модели для каждого потока. Вызовы инструментов в ответе на этот запрос всё равно выполняются, и их веб-поиски и время работы также учитываются в прейскурантной стоимости. Рассматривайте бюджет как ограничение на новую работу, а не как точную точку остановки, и выбирайте размер лимита с учётом этого запаса.
Сессия, достигшая своего бюджета, переходит в состояние idle со значением `stop_reason` (java, php: `stopReason`; csharp, go: `StopReason`), равным `budget_reached`; она не завершается, а её история и песочница сохраняются, как у любой другой сессии в состоянии idle. В [потоке событий](https://platform.claude.com/docs/ru/managed-agents/events-and-streaming) вы увидите по порядку:
1. Событие `session.thread_status_idle` со значением `stop_reason` (java, php: `stopReason`; csharp, go: `StopReason`), равным `budget_reached`, по мере приостановки каждого потока.
2. Событие [`session.usage`](https://platform.claude.com/docs/ru/managed-agents/budgets#monitor-spend) с накопленным использованием и прейскурантной стоимостью сессии.
3. Событие `session.status_idle` со значением `stop_reason` (java, php: `stopReason`; csharp, go: `StopReason`), равным `budget_reached`. Событие использования всегда непосредственно предшествует этому событию idle.
Если открыты [запуски рабочих процессов](https://platform.claude.com/docs/ru/managed-agents/workflow-runs#budgets-and-limits), каждый из них, который ещё не находится в простое, также получает событие `workflow_run.status_idle`.
Поток, чей последний запрос одновременно превышает лимит и завершает его ход, сообщает `end_turn` в своём собственном событии `session.thread_status_idle`, тогда как сессия по-прежнему сообщает `budget_reached`; считайте значение `stop_reason` (java, php: `stopReason`; csharp, go: `StopReason`) на уровне сессии сигналом того, что сессия приостановилась из-за бюджета.
### События, принимаемые при достижении лимита
Пока сессия находится на уровне бюджета или выше него, она принимает только события, которые завершают уже выполняемую работу:
* `user.tool_confirmation`
* `user.tool_result`
* `user.custom_tool_result`
* `user.interrupt`
Любое событие, которое начало бы новую работу, например `user.message`, отклоняется с ошибкой 400, в которой перечислен этот список. Завершающие результаты записываются без запуска нового запроса к модели; сессия остаётся приостановленной на своём бюджете.
Событие `user.interrupt`, отправленное, пока сессия приостановлена на уровне бюджета (все потоки приостановлены на лимите), принимается, и оно не появляется в списке событий. Оно не останавливает ни один поток, потому что каждый поток уже приостановлен. Чтобы продолжить, измените или удалите бюджет.
Если в сессии есть открытые [запуски рабочих процессов](https://platform.claude.com/docs/ru/managed-agents/workflow-runs#interrupt-a-session-with-runs-open), прерывание может приостановить их, как и прерывание в любое другое время. Запуск, приостановленный прерыванием, не возобновляется, когда вы изменяете или удаляете бюджет. Чтобы продолжить его, измените или удалите бюджет, а затем отправьте `user.message` с просьбой к агенту продолжить свои запуски.
## Возобновление сессии, достигшей бюджета
Измените или удалите бюджет с помощью обновления сессии. Принятое обновление автоматически возобновляет работу, приостановленную бюджетом; никаких дополнительных действий со стороны клиента не требуется.
Каждый [запуск рабочего процесса](https://platform.claude.com/docs/ru/managed-agents/workflow-runs#budgets-and-limits), приостановленный бюджетом, также получает событие `workflow_run.status_running`. Запуск, приостановленный прерыванием, даже если оно было отправлено, пока сессия находилась на уровне бюджета, остаётся приостановленным и не получает события `workflow_run.status_running` в результате обновления. Чтобы продолжить его, отправьте `user.message` с просьбой к агенту продолжить свои запуски. См. [Прерывание сессии с открытыми запусками](https://platform.claude.com/docs/ru/managed-agents/workflow-runs#interrupt-a-session-with-runs-open).
### Изменение бюджета
Обновите сессию, указав новое значение `max_list_cost` (java, php: `maxListCost`; csharp, go: `MaxListCost`). Новое значение может быть выше или ниже текущего лимита, но оно должно быть строго больше потреблённой прейскурантной стоимости сессии; в противном случае обновление отклоняется с ошибкой 400: `budget.max_list_cost must be greater than the session's consumed list cost`. Поскольку на момент приостановки сессии потреблённая стоимость обычно находится [немного выше старого лимита](https://platform.claude.com/docs/ru/managed-agents/budgets#when-a-session-reaches-its-budget), основывайте новое значение на сообщаемом значении `usage.list_cost` (java, php: `usage.listCost`; csharp, go: `Usage.ListCost`) сессии, а не на старом `max_list_cost` (java, php: `maxListCost`; csharp, go: `MaxListCost`). Задайте его хотя бы на цент выше этого значения: сообщаемое значение округлено и может быть немного ниже точной потреблённой стоимости, используемой при проверке.
```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
```
### Удаление бюджета
Передайте `"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`), чтобы полностью снять лимит. Работа, приостановленная бюджетом, возобновляется, а итоговое событие `session.updated` содержит `budget` (csharp, go: `Budget`) со значением `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#
// Присвоение null отправляет явный null; если Budget не задан, поле будет опущено.
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
// Budget с нулевым значением исключается из запроса; param.NullStruct (из
// github.com/anthropics/anthropic-sdk-go/packages/param) отправляет явный null.
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
// Пустой Optional отправляет явный null; если budget не задан, поле будет опущено.
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) опускает поле, поэтому передайте явный null как доп. параметр тела запроса.
$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
```
Удаление бюджета сессии необратимо: сессии, у которой бюджет был удалён, нельзя назначить новый. Если вы хотите сохранить лимит для сессии, измените бюджет, а не удаляйте его.
## Мониторинг расходов
Объект сессии содержит свой `budget` (csharp, go: `Budget`) и объект `usage` (csharp, go: `Usage`) с отслеживаемыми расходами: `usage.list_cost` (java, php: `usage.listCost`; csharp, go: `Usage.ListCost`) — это потреблённая прейскурантная стоимость сессии, а `usage.active_seconds` (java, php: `usage.activeSeconds`; csharp, go: `Usage.ActiveSeconds`) — время работы, на основе которого рассчитывается стоимость её выполнения. Для сессии, приостановленной с `budget_reached`, ожидайте, что `usage.list_cost` (java, php: `usage.listCost`; csharp, go: `Usage.ListCost`) будет равно `max_list_cost` (java, php: `maxListCost`; csharp, go: `MaxListCost`) или немного превышать его: [запрос, превысивший лимит](https://platform.claude.com/docs/ru/managed-agents/budgets#when-a-session-reaches-its-budget), завершился до приостановки. Значение `active_seconds` (java, php: `activeSeconds`; csharp, go: `ActiveSeconds`) на уровне сессии учитывает перекрывающуюся активность параллельных потоков один раз. Ответы на получение потока содержат те же два поля в собственном объекте `usage` (csharp, go: `Usage`) потока, рассчитанные для каждого потока. Значения для отдельных потоков округляются независимо и не включают стоимость времени работы сессии, поэтому их сумма не совпадает точно с `list_cost` (java, php: `listCost`; csharp, go: `ListCost`) сессии; бюджет применяется именно к значению сессии.
Событие `session.usage` — это снимок накопленного использования и отслеживаемой прейскурантной стоимости сессии. Оно содержит итоговые количества токенов сессии, `list_cost` (java, php: `listCost`; csharp, go: `ListCost`), `active_seconds` (java, php: `activeSeconds`; csharp, go: `ActiveSeconds`), количества запросов `server_tool_use` (java, php: `serverToolUse`; csharp, go: `ServerToolUse`) (`web_search_requests` (java, php: `webSearchRequests`; csharp, go: `WebSearchRequests`), учитываемые в прейскурантной стоимости за каждый запрос, и `web_fetch_requests` (java, php: `webFetchRequests`; csharp, go: `WebFetchRequests`), значение которого равно `0`, поскольку запросы веб-загрузки не тарифицируются за запрос и не учитываются), а также `budget` (csharp, go: `Budget`) сессии, если он у неё есть. Оно появляется в списке событий и в потоке сессии. Сессия отправляет его непосредственно перед переходом в состояние idle, какой бы ни была причина остановки, поэтому сессия, достигшая своего бюджета, всегда отправляет его непосредственно перед событием idle, связанным с достижением бюджета.
О том, как читать данные об использовании из потока и объекта сессии, см. [Отслеживание использования](https://platform.claude.com/docs/ru/managed-agents/session-observability#track-usage).
## Бюджеты в мультиагентных сессиях
[Мультиагентная](https://platform.claude.com/docs/ru/managed-agents/multiagent-orchestration) сессия имеет единый бюджет, общий для всех её потоков; лимитов на отдельные потоки нет. Потребление каждого потока оценивается по его собственной обслуживающей модели, и потоки приостанавливаются независимо по мере достижения общего лимита. Консультации [советника](https://platform.claude.com/docs/ru/managed-agents/multiagent-orchestration#give-the-session-an-advisor) учитываются в том же бюджете и оцениваются по тарифам модели советника. Один поток может приостановиться с `budget_reached`, пока другой завершает свой выполняющийся запрос.
Ожидающий запрос имеет приоритет над лимитом: сессия, в которой один поток ожидает в состоянии `requires_action`, а другой приостановлен с `budget_reached`, сообщает `requires_action` на уровне сессии. Ожидающий запрос по-прежнему требует ответа, а ответ на него — это [завершающее событие](https://platform.claude.com/docs/ru/managed-agents/budgets#events-accepted-at-the-cap), которое бюджет не блокирует.
## Бюджеты в развёртываниях
[Развёртывание](https://platform.claude.com/docs/ru/managed-agents/scheduled-deployments) принимает тот же объект `budget` при его создании или обновлении:
```json
{
"budget": {
"type": "limit",
"max_list_cost": { "amount": "2000", "currency": "USD" }
}
}
```
Лимит копируется в каждую сессию, запускаемую развёртыванием, поэтому он ограничивает каждый запуск по отдельности, а не совокупные расходы развёртывания. Изменение бюджета развёртывания применяется к сессиям, которые развёртывание запускает после этого, а не к уже выполняющимся сессиям. В отличие от сессии, бюджет развёртывания можно очистить с помощью `"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`) и позже установить снова. См. [Установка бюджета для каждого запуска](https://platform.claude.com/docs/ru/managed-agents/scheduled-deployments#set-a-budget-on-each-run).
## Модели без прейскурантной цены
Бюджет может отслеживать только то потребление, которое платформа способна оценить. Создание сессии с бюджетом, чей агент, или любой агент из списка `predefined_agents` (java, php: `predefinedAgents`; csharp, go: `PredefinedAgents`) в `subagents` (csharp, go: `Subagents`) или `workflows` (csharp, go: `Workflows`), или советник, заданный в её [мультиагентной конфигурации](https://platform.claude.com/docs/ru/managed-agents/multiagent-orchestration), использует модель без публичной прейскурантной цены, отклоняется с ошибкой 400, сообщающей, что для модели нет прейскурантной цены.
Если использование сессии с бюджетом начинает включать модель без прейскурантной цены, бюджет больше не может измерять расходы сессии: сессия может приостановиться со значением `stop_reason` (java, php: `stopReason`; csharp, go: `StopReason`), равным `budget_reached`, а изменение бюджета отклоняется. Чтобы возобновить сессию, удалите бюджет.
## Справочник ошибок
Запросы, связанные с бюджетом, отклоняются в следующих случаях:
| Условие | Статус |
| ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------ |
| Событие, начинающее работу (например, `user.message`), отправлено, пока сессия находится на уровне бюджета или выше него; в ошибке перечислены [принимаемые завершающие события](https://platform.claude.com/docs/ru/managed-agents/budgets#events-accepted-at-the-cap) | 400 |
| Бюджет установлен в значение, равное потреблённой прейскурантной стоимости сессии или ниже её | 400 |
| Бюджет добавляется к сессии, созданной без него, или добавляется повторно после удаления | 400 |
| `amount` (csharp, go: `Amount`) не является целым числом центов (например, `"25.00"`), равно нулю или отрицательно, либо `currency` (csharp, go: `Currency`) не равно `USD` | 400 |
| Создание с бюджетом ссылается на модель [без публичной прейскурантной цены](https://platform.claude.com/docs/ru/managed-agents/budgets#models-without-a-list-price) | 400 |
Бюджеты сессий — это жёсткие лимиты в долларах США (записываемые в центах) на одну сессию, применяемые платформой. Они отличаются от [бюджетов задач](https://platform.claude.com/docs/ru/build-with-claude/task-budgets) Messages API, которые являются рекомендательными, выраженными в токенах бюджетами, используемыми моделью для саморегуляции в рамках одного агентного цикла.