---
title: セッション予算
url: https://platform.claude.com/docs/ja/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/ja/managed-agents/sessions)する際に設定できる、オプションの厳格な支出上限です。プラットフォームは、セッションが消費するすべてのものを公開リスト料金で継続的に価格計算し（これがセッションの**リストコスト**（list cost）です）、そのコストが予算に達すると新しいモデルリクエストの発行を停止します。上限を超えた時点で処理中だったリクエストは完了まで実行されるため、最終的なリストコストは[予算をわずかに超える](https://platform.claude.com/docs/ja/managed-agents/budgets#when-a-session-reaches-its-budget)ことがあります。予算に達したセッションは終了するのではなく、一時停止して[アイドル](https://platform.claude.com/docs/ja/managed-agents/session-operations#session-statuses)状態になります。予算を変更または削除すると、予算によって一時停止された作業が再開されます。デプロイメントも同じ予算を受け付け、開始する各セッションにそれを適用します。[デプロイメントの予算](https://platform.claude.com/docs/ja/managed-agents/budgets#budgets-on-deployments)を参照してください。

## セッション作成時に予算を設定する

セッションを作成する際に、オプションの `budget` (csharp, go: `Budget`) フィールドを渡します。

<CodeGroup>
  ```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
  ```
</CodeGroup>

`budget` (csharp, go: `Budget`) オブジェクトには2つのフィールドがあります。

* `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/ja/managed-agents/budgets#change-the-budget)または[削除](https://platform.claude.com/docs/ja/managed-agents/budgets#remove-the-budget)できます。

## リストコストの測定方法

プラットフォームは、セッションが消費するものを公開リスト料金で継続的に価格計算します。

* **モデルトークン**：提供された各モデルのリスト価格
* **ウェブ検索**：1,000回の検索あたり10米ドル
* **セッション実行時間**：1時間あたり0.08米ドル

この累計ドル合計がセッションの**リストコスト**であり、予算はこれと比較されます。リストコストは契約価格ではありません。組織が割引を交渉している場合、セッションはリスト価格の合計が上限に達した時点で上限に達するため、実際の請求額は上限より低くなる可能性があります。

適用には、丸められていない正確なリストコストが使用されます。セッションとそのイベントで報告される `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"` の状態で一時停止することがあります。これは想定された動作であり、請求エラーではありません。上限を超えたモデル支出は、最大でもスレッドごとに1回のモデルリクエストのコストです。そのリクエストのレスポンスに含まれるツール呼び出しは引き続き実行され、それらのウェブ検索と実行時間もリストコストに加算されます。予算は正確な停止点ではなく新しい作業に対する上限として扱い、その余裕を考慮して上限を設定してください。

予算に達したセッションは、`stop_reason` (java, php: `stopReason`; csharp, go: `StopReason`) が `budget_reached` の状態でアイドルになります。セッションは終了されず、その履歴とサンドボックスは他のアイドルセッションと同様に保持されます。[イベントストリーム](https://platform.claude.com/docs/ja/managed-agents/events-and-streaming)では、次の順序でイベントが表示されます。

1. 各スレッドが一時停止するたびに、`stop_reason` (java, php: `stopReason`; csharp, go: `StopReason`) が `budget_reached` の `session.thread_status_idle` イベント。
2. セッションの累積使用量とリストコストを含む [`session.usage`](https://platform.claude.com/docs/ja/managed-agents/budgets#monitor-spend) イベント。
3. `stop_reason` (java, php: `stopReason`; csharp, go: `StopReason`) が `budget_reached` の `session.status_idle` イベント。usageイベントは常にこのアイドルイベントの直前に発生します。

[ワークフロー実行](https://platform.claude.com/docs/ja/managed-agents/workflow-runs#budgets-and-limits)が開いている場合、まだアイドルになっていない各実行にも `workflow_run.status_idle` イベントが送られます。

最後のリクエストで上限を超え、かつターンを完了したスレッドは、自身の `session.thread_status_idle` イベントで `end_turn` を報告しますが、セッションは引き続き `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/ja/managed-agents/workflow-runs#interrupt-a-session-with-runs-open)がある場合、他のタイミングでの中断と同様に、この中断によってそれらの実行が一時停止することがあります。中断によって一時停止された実行は、予算を変更または削除しても再開されません。その実行を続行するには、予算を変更または削除してから、実行を続行するようエージェントに依頼する `user.message` を送信してください。

## 予算に達したセッションを再開する

セッションの更新によって予算を変更または削除します。更新が受け付けられると、予算によって一時停止された作業は自動的に再開され、クライアント側で追加の操作は必要ありません。

予算によって一時停止された各[ワークフロー実行](https://platform.claude.com/docs/ja/managed-agents/workflow-runs#budgets-and-limits)にも、`workflow_run.status_running` イベントが送られます。中断によって一時停止された実行は、セッションが予算に達している間に送信された中断によるものであっても、一時停止したままになり、更新による `workflow_run.status_running` イベントは送られません。その実行を続行するには、実行を続行するようエージェントに依頼する `user.message` を送信してください。[実行が開いているセッションを中断する](https://platform.claude.com/docs/ja/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/ja/managed-agents/budgets#when-a-session-reaches-its-budget)ため、新しい値は古い `max_list_cost` (java, php: `maxListCost`; csharp, go: `MaxListCost`) ではなく、セッションで報告される `usage.list_cost` (java, php: `usage.listCost`; csharp, go: `Usage.ListCost`) に基づいて決めてください。その数値より1セント以上高く設定してください。報告される値は丸められており、チェックに使用される正確な消費済みコストをわずかに下回る場合があります。

<CodeGroup>
  ```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
  ```
</CodeGroup>

### 予算を削除する

上限を完全に削除するには、`"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` に設定されています。

<CodeGroup>
  ```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
  ```
</CodeGroup>

<Warning>
  セッションの予算の削除は一方向の操作です。予算が削除されたセッションに新しい予算を設定することはできません。セッションに上限を維持したい場合は、代わりに予算を変更してください。
</Warning>

## 支出を監視する

セッションオブジェクトには、その `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/ja/managed-agents/budgets#when-a-session-reaches-its-budget)は一時停止の前に完了しているためです。セッションレベルの `active_seconds` (java, php: `activeSeconds`; csharp, go: `ActiveSeconds`) は、並行するスレッドの重複するアクティビティを1回としてカウントします。スレッド取得のレスポンスには、スレッド自身の `usage` (csharp, go: `Usage`) に同じ2つのフィールドが含まれ、スレッドごとに価格計算されます。スレッドごとの数値は個別に丸められ、セッションの実行時間コストを含まないため、合計してもセッションの `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`) と、ウェブフェッチリクエストにはリクエストごとの料金がなく計測されないため `0` となる `web_fetch_requests` (java, php: `webFetchRequests`; csharp, go: `WebFetchRequests`)）、およびセッションに予算がある場合はその `budget` (csharp, go: `Budget`) が含まれます。このイベントはイベントリストとセッションストリームに表示されます。セッションは停止理由にかかわらず、アイドルになる直前にこのイベントを1つ発行するため、予算に達したセッションは、予算到達のアイドルイベントの直前に必ずこのイベントを発行します。

ストリームとセッションオブジェクトから使用量を読み取る方法については、[使用量を追跡する](https://platform.claude.com/docs/ja/managed-agents/session-observability#track-usage)を参照してください。

## マルチエージェントセッションにおける予算

[マルチエージェント](https://platform.claude.com/docs/ja/managed-agents/multiagent-orchestration)セッションには、すべてのスレッドで共有される単一の予算があり、スレッドごとの上限はありません。各スレッドの消費はそれぞれの提供モデルで価格計算され、共有の上限に達するとスレッドは個別に一時停止します。[アドバイザー](https://platform.claude.com/docs/ja/managed-agents/multiagent-orchestration#give-the-session-an-advisor)への相談も同じ予算に計上され、アドバイザーモデルの料金で価格計算されます。あるスレッドが `budget_reached` で一時停止している間に、別のスレッドが処理中のリクエストを完了することがあります。

保留中の問い合わせは上限より優先されます。あるスレッドが `requires_action` で待機中で、別のスレッドが `budget_reached` で一時停止しているセッションは、セッションレベルでは `requires_action` を報告します。保留中のリクエストには依然として回答が必要であり、それに回答することは予算によってブロックされない[完結イベント](https://platform.claude.com/docs/ja/managed-agents/budgets#events-accepted-at-the-cap)です。

## デプロイメントの予算

[デプロイメント](https://platform.claude.com/docs/ja/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/ja/managed-agents/scheduled-deployments#set-a-budget-on-each-run)を参照してください。

## リスト価格のないモデル

予算は、プラットフォームが価格計算できる消費のみを追跡できます。予算付きセッションを作成する際に、そのエージェント、`subagents` (csharp, go: `Subagents`) または `workflows` (csharp, go: `Workflows`) の `predefined_agents` (java, php: `predefinedAgents`; csharp, go: `PredefinedAgents`) リストに含まれるいずれかのエージェント、または[マルチエージェント構成](https://platform.claude.com/docs/ja/managed-agents/multiagent-orchestration)で設定されたアドバイザーが、公開リスト価格のないモデルを使用している場合、そのモデルのリスト価格が利用できないことを示す400エラーで拒否されます。

予算付きセッションの使用量にリスト価格のないモデルが含まれるようになった場合、予算はセッションの支出を測定できなくなります。セッションは `stop_reason` (java, php: `stopReason`; csharp, go: `StopReason`) が `budget_reached` の状態で一時停止する可能性があり、予算の変更は拒否されます。セッションを再開するには、予算を削除してください。

## エラーリファレンス

予算関連のリクエストは、次の場合に拒否されます。

| 条件                                                                                                                                                                              | ステータス |
| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----- |
| セッションが予算に達しているか超過している間に、作業を開始するイベント（例：`user.message`）が送信された場合。エラーには[受け付けられる完結イベント](https://platform.claude.com/docs/ja/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/ja/managed-agents/budgets#models-without-a-list-price)モデルを参照している場合                                                   | 400   |

<Note>
  セッション予算は、単一のセッションに対する米ドル建て（セント単位で記述）の厳格な上限であり、プラットフォームによって適用されます。これは、Messages APIの[タスク予算](https://platform.claude.com/docs/ja/build-with-claude/task-budgets)とは異なります。タスク予算は、モデルが1つのエージェントループ内で自己調整するために使用する、助言的なトークン建ての予算です。
</Note>