---
title: 工作階段預算
url: https://platform.claude.com/docs/zh-TW/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/zh-TW/managed-agents/sessions)時可選擇設定的硬性支出上限。平台會持續以公開定價費率為工作階段所消耗的一切計價（即工作階段的 **list cost**（定價成本）），並在該成本達到預算時停止發出新的模型請求。跨越上限時正在進行中的請求仍會完成，因此最終的定價成本可能會[略微超出預算](https://platform.claude.com/docs/zh-TW/managed-agents/budgets#when-a-session-reaches-its-budget)。達到預算的工作階段會暫停並進入 [idle](https://platform.claude.com/docs/zh-TW/managed-agents/session-operations#session-statuses)（閒置）狀態，而非終止；變更或移除預算會恢復被預算暫停的工作。部署（deployment）接受相同的預算，並將其套用至它所啟動的每個工作階段；請參閱[部署上的預算](https://platform.claude.com/docs/zh-TW/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`) 物件有兩個欄位：

* `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/zh-TW/managed-agents/budgets#change-the-budget)或[移除](https://platform.claude.com/docs/zh-TW/managed-agents/budgets#remove-the-budget)。

## 定價成本的計算方式

平台會持續以公開定價費率為工作階段所消耗的項目計價：

* **模型 token**，依各個實際服務模型的定價
* **網頁搜尋**，每 1,000 次搜尋 $10 美元
* **工作階段執行時間**，每小時 $0.08 美元

這個累計的美元總額即為工作階段的 **list cost**（定價成本），也是預算所比對的對象。定價成本並非您的合約價格：如果您的組織已協商折扣，工作階段會在定價總額達到上限時達到上限，而您實際計費的支出可能低於該上限。

強制執行使用的是精確、未經捨入的定價成本。工作階段及其事件上回報的 `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"` 時暫停。這是預期行為，並非計費錯誤。超出上限的模型支出，最多為每個執行緒一次模型請求的成本。該請求回應中的工具呼叫仍會執行，其網頁搜尋與執行時間也會計入定價成本。請將預算視為對新工作的限制，而非精確的停止點，並在設定上限時考量這個餘裕。

達到預算的工作階段會進入閒置狀態，其 `stop_reason` (java, php: `stopReason`; csharp, go: `StopReason`) 為 `budget_reached`；它不會被終止，其歷史記錄與沙箱會像其他閒置工作階段一樣被保留。在[事件串流](https://platform.claude.com/docs/zh-TW/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/zh-TW/managed-agents/budgets#monitor-spend) 事件，包含工作階段的累計用量與定價成本。
3. 一個 `stop_reason` (java, php: `stopReason`; csharp, go: `StopReason`) 為 `budget_reached` 的 `session.status_idle` 事件。用量事件一律緊接在此閒置事件之前。

如果有開啟中的[工作流程執行](https://platform.claude.com/docs/zh-TW/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/zh-TW/managed-agents/workflow-runs#interrupt-a-session-with-runs-open)，該中斷可能會暫停它們，就像在其他任何時候傳送的中斷一樣。被中斷暫停的執行不會在您變更或移除預算時恢復。若要繼續該執行，請變更或移除預算，接著傳送一則 `user.message`，要求代理繼續其執行。

## 恢復達到預算的工作階段

透過工作階段更新來變更或移除預算。被接受的更新會自動恢復被預算暫停的工作；用戶端無需採取進一步動作。

每個被預算暫停的[工作流程執行](https://platform.claude.com/docs/zh-TW/managed-agents/workflow-runs#budgets-and-limits)也會收到一個 `workflow_run.status_running` 事件。被中斷暫停的執行（即使該中斷是在工作階段已達到預算時傳送的）會維持暫停，且不會因該更新而收到 `workflow_run.status_running` 事件。若要繼續該執行，請傳送一則 `user.message`，要求代理繼續其執行。請參閱[在有開啟的執行時中斷工作階段](https://platform.claude.com/docs/zh-TW/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/zh-TW/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`)。請將其設定為比該數值高出一美分或更多：回報的數值經過捨入，可能略低於檢查所使用的精確已消耗成本。

<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 作為額外的 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
  ```
</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/zh-TW/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` 事件是工作階段累計用量與所追蹤定價成本的快照。它帶有工作階段的 token 總數、`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`)（若工作階段有設定）。它會出現在事件清單與工作階段串流中。無論停止原因為何，工作階段都會在進入閒置前立即發出一個此事件，因此達到預算的工作階段一律會在預算已達的閒置事件之前立即發出一個此事件。

若要從串流和工作階段物件讀取用量，請參閱[追蹤用量](https://platform.claude.com/docs/zh-TW/managed-agents/session-observability#track-usage)。

## 多代理工作階段中的預算

[多代理](https://platform.claude.com/docs/zh-TW/managed-agents/multiagent-orchestration)工作階段有一個由其所有執行緒共用的單一預算；沒有各執行緒的上限。每個執行緒的消耗依其自身的實際服務模型計價，且執行緒會在達到共用上限時各自獨立暫停。[顧問（Advisor）](https://platform.claude.com/docs/zh-TW/managed-agents/multiagent-orchestration#give-the-session-an-advisor)諮詢計入同一預算，依顧問模型的費率計價。一個執行緒可能在 `budget_reached` 暫停，而另一個執行緒則完成其進行中的請求。

待處理的詢問優先於上限：若工作階段有一個執行緒正在等待 `requires_action`，而另一個執行緒在 `budget_reached` 暫停，則工作階段層級會回報 `requires_action`。待處理的請求仍需要回答，而回答它屬於預算不會阻擋的[結算事件](https://platform.claude.com/docs/zh-TW/managed-agents/budgets#events-accepted-at-the-cap)。

## 部署上的預算

[部署](https://platform.claude.com/docs/zh-TW/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/zh-TW/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/zh-TW/managed-agents/multiagent-orchestration)中設定的顧問，使用了沒有公開定價的模型，則會以 400 錯誤被拒絕，錯誤訊息會說明該模型沒有可用的定價。

如果已設定預算的工作階段的用量開始包含沒有定價的模型，預算將無法再衡量工作階段的支出：工作階段可能會以 `budget_reached` 的 `stop_reason` (java, php: `stopReason`; csharp, go: `StopReason`) 暫停，且變更預算會被拒絕。請移除預算以恢復工作階段。

## 錯誤參考

與預算相關的請求在下列情況下會被拒絕：

| 條件                                                                                                                                                  | 狀態  |
| --------------------------------------------------------------------------------------------------------------------------------------------------- | --- |
| 在工作階段達到或超過其預算時送出啟動工作的事件（例如 `user.message`）；錯誤會列出[接受的結算事件](https://platform.claude.com/docs/zh-TW/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/zh-TW/managed-agents/budgets#models-without-a-list-price)的模型                                 | 400 |

<Note>
  工作階段預算是針對單一工作階段、以美元（以美分表示）計的硬性上限，由平台強制執行。它們與 Messages API 的[任務預算](https://platform.claude.com/docs/zh-TW/build-with-claude/task-budgets)不同，後者是建議性、以 token 計的預算，供模型在單一代理迴圈中自我調節使用。
</Note>