---
title: Sitzungsbudgets
url: https://platform.claude.com/docs/de/managed-agents/budgets
description: Begrenze die Ausgaben einer Sitzung mit einem harten Dollar-Budget, das zu öffentlichen Listenpreisen durchgesetzt wird.
featureMetadata:
topic:
title: Managed Agents
url: https://platform.claude.com/docs/en/managed-agents/overview
status: beta
betaHeader: managed-agents-2026-04-01
zdr:
eligibility: not-eligible
note: Nicht für ZDR berechtigt, außer bei selbst gehosteten Managed Agents. Sitzungen sind zustandsbehaftete Ressourcen; Transkripte bleiben erhalten, bis du sie löschst.
supportedModels:
- claude-fable-5-2
- claude-mythos-5-2
- claude-fable-5-1
- claude-mythos-5-1
- claude-fable-5
- claude-mythos-5
- claude-mythos-preview
- claude-opus-5-5
- claude-opus-5
- claude-sonnet-5-5
- claude-sonnet-5
- claude-haiku-5-5
- claude-haiku-4-5-20251001
- claude-opus-4-8
- claude-opus-4-7
- claude-opus-4-6
- claude-sonnet-4-6
- claude-opus-4-5-20251101
- claude-sonnet-4-5-20250929
supportedPlatforms:
Claude API: beta
Claude Platform on AWS: beta
Claude Models on Google Cloud (Anthropic managed): beta
---
Ein „session budget“ (Session-Budget) ist eine optionale feste Ausgabenobergrenze, die du festlegst, wenn du [eine Session erstellst](https://platform.claude.com/docs/de/managed-agents/sessions). Die Plattform bepreist fortlaufend alles, was die Session verbraucht, zu öffentlichen Listenpreisen (die „**list cost**“ (Listenkosten) der Session) und stellt keine neuen Modellanfragen mehr, sobald diese Kosten das Budget erreichen. Die Anfrage, die gerade läuft, wenn die Obergrenze überschritten wird, wird trotzdem abgeschlossen, sodass die endgültigen Listenkosten [geringfügig über dem Budget](https://platform.claude.com/docs/de/managed-agents/budgets#when-a-session-reaches-its-budget) liegen können. Eine Session, die ihr Budget erreicht hat, pausiert und wechselt in den Status [idle](https://platform.claude.com/docs/de/managed-agents/session-operations#session-statuses), anstatt beendet zu werden; das Ändern oder Entfernen des Budgets setzt die Arbeit fort, die das Budget pausiert hat. Deployments akzeptieren dasselbe Budget und wenden es auf jede Session an, die sie starten; siehe [Budgets für Deployments](https://platform.claude.com/docs/de/managed-agents/budgets#budgets-on-deployments).
## Ein Budget bei der Sitzungserstellung festlegen
Übergib das optionale Feld `budget` (csharp, go: `Budget`), wenn du die Sitzung erstellst:
```bash cURL
curl -sS --fail-with-body https://api.anthropic.com/v1/sessions \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2026-10-21" \
-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
# Lass den Betrag in Anführungszeichen, damit er als String und nicht als Zahl gesendet wird.
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()
{
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{
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()
.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
```
Das Objekt `budget` (csharp, go: `Budget`) hat zwei Felder:
* `type` (csharp, go: `Type`) ist immer `"limit"`.
* `max_list_cost` (java, php: `maxListCost`; csharp, go: `MaxListCost`) ist die Obergrenze selbst: `amount` (csharp, go: `Amount`) ist eine ganze Zahl von US-Cent, geschrieben als String ohne führende Nullen (`"125"` entspricht 1,25 $ (USD) und `"50"` entspricht 50 Cent), und muss größer als null sein. Dezimalformen wie `"25.00"` werden abgelehnt. Der Betrag ist ein String statt einer Zahl, damit niemals eine Gleitkomma-Rundung darauf angewendet wird. `currency` (csharp, go: `Currency`) ist ein ISO-4217-Währungscode in Großbuchstaben; `USD` ist die einzige unterstützte Währung.
Ein Budget kann nur beim Erstellen der Sitzung angehängt werden. Das Hinzufügen eines Budgets zu einer bestehenden Sitzung, die keines hat, wird mit einem 400-Fehler abgelehnt. Die Obergrenze einer budgetierten Sitzung kann jederzeit [geändert](https://platform.claude.com/docs/de/managed-agents/budgets#change-the-budget) oder [entfernt](https://platform.claude.com/docs/de/managed-agents/budgets#remove-the-budget) werden.
## Wie Listenkosten gemessen werden
Die Plattform bepreist fortlaufend, was die Sitzung verbraucht, zu öffentlichen Listenpreisen:
* **Modell-Token**, zum Listenpreis des jeweils bereitgestellten Modells
* **Websuchen**, zu 10 USD pro 1.000 Suchen
* **Sitzungslaufzeit**, zu 0,08 USD pro Stunde
Diese laufende Dollar-Gesamtsumme sind die **Listenkosten** der Sitzung, und mit ihnen wird das Budget verglichen. Listenkosten sind nicht dein vertraglich vereinbarter Preis: Wenn deine Organisation Rabatte ausgehandelt hat, erreicht die Sitzung ihre Obergrenze, wenn die Listenpreis-Gesamtsumme sie erreicht, und deine abgerechneten Ausgaben können niedriger als die Obergrenze sein.
Die Durchsetzung verwendet die exakten, ungerundeten Listenkosten. Die Werte für `list_cost` (java, php: `listCost`; csharp, go: `ListCost`), die für die Sitzung und ihre Events gemeldet werden, sind ganze Cent, auf den nächsten Cent gerundet, sodass ein gemeldeter Wert bis zu einem halben Cent über oder unter dem exakten Betrag liegen kann, den die Durchsetzung verwendet.
## Wenn eine Sitzung ihr Budget erreicht
Die Obergrenze wird zwischen Modellanfragen durchgesetzt, nicht mitten in einer Anfrage. Vor jeder Modellanfrage prüft die Plattform die verbrauchten Listenkosten der Session, und sobald diese Summe die Obergrenze erreicht, pausiert jeder Thread vor seiner nächsten Anfrage. Die Anfrage, die die Summe über die Obergrenze getragen hat, wurde zugelassen, als die Session noch darunter lag, und läuft bis zum Ende. Daher liegen die erfassten `list_cost` (java, php: `listCost`; csharp, go: `ListCost`) einer pausierten Session bei oder geringfügig über `max_list_cost` (java, php: `maxListCost`; csharp, go: `MaxListCost`). Beispielsweise kann eine Session mit einer Obergrenze von `"50"` (50 Cent) mit `list_cost` (java, php: `listCost`; csharp, go: `ListCost`) von `"53"` pausieren. Das ist zu erwarten und kein Abrechnungsfehler. Die Modellausgaben über der Obergrenze betragen höchstens die Kosten einer Modellanfrage pro Thread. Die Tool-Aufrufe in der Antwort dieser Anfrage werden trotzdem ausgeführt, und ihre Websuchen und ihre Laufzeit zählen ebenfalls zu den Listenkosten. Betrachte das Budget als Grenze für neue Arbeit statt als exakten Haltepunkt und bemiss die Obergrenze mit diesem Spielraum im Hinterkopf.
Eine Sitzung, die ihr Budget erreicht, wechselt in den Status idle mit einem `stop_reason` (java, php: `stopReason`; csharp, go: `StopReason`) von `budget_reached`; sie wird nicht beendet, und ihr Verlauf und ihre Sandbox bleiben wie bei jeder anderen inaktiven Sitzung erhalten. Im [Event-Stream](https://platform.claude.com/docs/de/managed-agents/events-and-streaming) siehst du der Reihe nach:
1. Ein `session.thread_status_idle`-Event mit einem `stop_reason` (java, php: `stopReason`; csharp, go: `StopReason`) von `budget_reached`, wenn jeder Thread pausiert.
2. Ein [`session.usage`](https://platform.claude.com/docs/de/managed-agents/budgets#monitor-spend)-Event mit der kumulierten Nutzung und den Listenkosten der Sitzung.
3. Ein `session.status_idle`-Event mit einem `stop_reason` (java, php: `stopReason`; csharp, go: `StopReason`) von `budget_reached`. Das Nutzungs-Event geht diesem Idle-Event immer unmittelbar voraus.
Wenn [Workflow-Runs](https://platform.claude.com/docs/de/managed-agents/workflow-runs#budgets-and-limits) offen sind, erhält jeder, der nicht bereits inaktiv ist, außerdem ein `workflow_run.status_idle`-Event.
Ein Thread, dessen letzte Anfrage sowohl die Obergrenze überschreitet als auch seinen Turn abschließt, meldet `end_turn` in seinem eigenen `session.thread_status_idle`-Event, während die Sitzung weiterhin `budget_reached` meldet; betrachte den `stop_reason` (java, php: `stopReason`; csharp, go: `StopReason`) auf Sitzungsebene als das Signal, dass die Sitzung bei ihrem Budget pausiert hat.
### An der Obergrenze akzeptierte Events
Solange die Sitzung bei oder über ihrem Budget liegt, akzeptiert sie nur Events, die bereits laufende Arbeit abschließen:
* `user.tool_confirmation`
* `user.tool_result`
* `user.custom_tool_result`
* `user.interrupt`
Jedes Event, das neue Arbeit starten würde, wie `user.message`, wird mit einem 400-Fehler abgelehnt, der diese Liste nennt. Abgeschlossene Ergebnisse werden aufgezeichnet, ohne eine neue Modellanfrage auszulösen; die Sitzung bleibt an ihrem Budget pausiert.
Ein `user.interrupt`, das gesendet wird, während die Sitzung an ihrem Budget pausiert ist (alle Threads an der Obergrenze pausiert), wird akzeptiert, und es erscheint nicht in der Event-Liste. Es stoppt keinen Thread, weil jeder Thread bereits pausiert ist. Ändere oder entferne das Budget, um fortzufahren.
Wenn die Session offene Workflow-Runs hat, kann die Unterbrechung diese pausieren, so wie es eine Unterbrechung zu jedem anderen Zeitpunkt auch kann. Ein Run, den eine Unterbrechung pausiert hat, wird nicht fortgesetzt, wenn du das Budget änderst oder entfernst. Um ihn fortzusetzen, ändere oder entferne das Budget und sende dann eine `user.message`, in der du den Agenten bittest, seine Runs fortzusetzen. Siehe [Eine Session mit offenen Runs unterbrechen](https://platform.claude.com/docs/de/managed-agents/workflow-runs#interrupt-a-session-with-runs-open).
## Eine Sitzung an ihrem Budget fortsetzen
Ändere oder entferne das Budget mit einem Sitzungs-Update. Ein akzeptiertes Update setzt die Arbeit, die das Budget pausiert hat, automatisch fort; es ist keine weitere Aktion des Clients erforderlich.
Jeder [Workflow-Run](https://platform.claude.com/docs/de/managed-agents/workflow-runs#budgets-and-limits), den das Budget pausiert hat, erhält außerdem ein `workflow_run.status_running`-Event. Ein Run, den eine Unterbrechung pausiert hat, bleibt pausiert und erhält durch das Update kein `workflow_run.status_running`-Event, selbst wenn die Unterbrechung gesendet wurde, während die Sitzung an ihrem Budget war. Um ihn fortzusetzen, sende eine `user.message`, die den Agenten bittet, seine Runs fortzusetzen. Siehe [Eine Session mit offenen Runs unterbrechen](https://platform.claude.com/docs/de/managed-agents/workflow-runs#interrupt-a-session-with-runs-open).
### Das Budget ändern
Aktualisiere die Sitzung mit einem neuen `max_list_cost` (java, php: `maxListCost`; csharp, go: `MaxListCost`). Der neue Wert kann höher oder niedriger als die aktuelle Obergrenze sein, muss aber strikt größer als die verbrauchten Listenkosten der Sitzung sein; andernfalls wird das Update mit einem 400-Fehler abgelehnt: `budget.max_list_cost must be greater than the session's consumed list cost`. Da die verbrauchten Kosten beim Pausieren der Sitzung meist [geringfügig über der alten Obergrenze](https://platform.claude.com/docs/de/managed-agents/budgets#when-a-session-reaches-its-budget) liegen, orientiere den neuen Wert am gemeldeten `usage.list_cost` (java, php: `usage.listCost`; csharp, go: `Usage.ListCost`) der Sitzung, nicht am alten `max_list_cost` (java, php: `maxListCost`; csharp, go: `MaxListCost`). Setze ihn einen Cent oder mehr über diesen Wert: Der gemeldete Wert ist gerundet und kann geringfügig unter den exakten verbrauchten Kosten liegen, die die Prüfung verwendet.
```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: 2026-10-21" \
-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()
{
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{
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()
.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
```
### Das Budget entfernen
Übergib `"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`), um die Obergrenze vollständig zu entfernen. Die Arbeit, die das Budget pausiert hat, wird fortgesetzt, und das resultierende `session.updated`-Event enthält `budget` (csharp, go: `Budget`) mit dem Wert `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: 2026-10-21" \
-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#
// Die Zuweisung von null sendet ein explizites null; bleibt Budget ungesetzt, wird das Feld weggelassen.
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
// Ein Budget mit Nullwert wird aus der Anfrage weggelassen; param.NullStruct (aus
// github.com/anthropics/anthropic-sdk-go/v2/packages/param) sendet explizit 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
// Ein leeres Optional sendet ein explizites null; budget ungesetzt zu lassen würde das Feld weglassen.
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) lässt das Feld weg, also sende das explizite null als zusätzlichen Body-Parameter.
$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
```
Das Entfernen des Budgets einer Sitzung ist unumkehrbar: Einer Sitzung, deren Budget entfernt wurde, kann kein neues gegeben werden. Um eine Obergrenze für die Sitzung beizubehalten, ändere stattdessen das Budget.
## Ausgaben überwachen
Das Session-Objekt enthält sein `budget` (csharp, go: `Budget`) und ein `usage` (csharp, go: `Usage`)-Objekt mit den erfassten Ausgaben: `usage.list_cost` (java, php: `usage.listCost`; csharp, go: `Usage.ListCost`) sind die verbrauchten Listenkosten der Session, und `usage.active_seconds` (java, php: `usage.activeSeconds`; csharp, go: `Usage.ActiveSeconds`) ist die Laufzeit, auf deren Basis die Laufzeitkosten berechnet werden. Bei einer Session, die mit `budget_reached` pausiert ist, ist zu erwarten, dass `usage.list_cost` (java, php: `usage.listCost`; csharp, go: `Usage.ListCost`) bei oder geringfügig über `max_list_cost` (java, php: `maxListCost`; csharp, go: `MaxListCost`) liegt: Die [Anfrage, die die Obergrenze überschritten hat](https://platform.claude.com/docs/de/managed-agents/budgets#when-a-session-reaches-its-budget), wurde vor der Pause abgeschlossen. `active_seconds` (java, php: `activeSeconds`; csharp, go: `ActiveSeconds`) auf Session-Ebene zählt überlappende Aktivität gleichzeitiger Threads nur einmal. Antworten beim Abrufen von Threads enthalten dieselben zwei Felder im eigenen `usage` (csharp, go: `Usage`) des Threads, pro Thread bepreist. Die Werte pro Thread werden unabhängig voneinander gerundet und schließen die Laufzeitkosten der Session aus, sodass sie sich nicht exakt zu den `list_cost` (java, php: `listCost`; csharp, go: `ListCost`) der Session aufsummieren; der Session-Wert ist derjenige, gegen den das Budget durchgesetzt wird.
Das `session.usage`-Event ist eine Momentaufnahme der kumulierten Nutzung und der erfassten Listenkosten der Sitzung. Es enthält die Token-Summen der Sitzung, `list_cost` (java, php: `listCost`; csharp, go: `ListCost`), `active_seconds` (java, php: `activeSeconds`; csharp, go: `ActiveSeconds`), die Anfragezahlen in `server_tool_use` (java, php: `serverToolUse`; csharp, go: `ServerToolUse`) (`web_search_requests` (java, php: `webSearchRequests`; csharp, go: `WebSearchRequests`), pro Anfrage in die Listenkosten eingerechnet, und `web_fetch_requests` (java, php: `webFetchRequests`; csharp, go: `WebFetchRequests`), das `0` anzeigt, weil Web-Fetch-Anfragen keine Gebühr pro Anfrage haben und nicht gemessen werden) sowie das `budget` (csharp, go: `Budget`) der Sitzung, falls die Sitzung eines hat. Es erscheint in der Event-Liste und im Sitzungs-Stream. Die Sitzung sendet eines unmittelbar bevor sie in den Status idle wechselt, unabhängig vom Stop-Grund, sodass eine Sitzung, die ihr Budget erreicht, immer eines unmittelbar vor dem Idle-Event für das erreichte Budget sendet.
Wie du die Nutzung aus dem Stream und dem Sitzungsobjekt ausliest, erfährst du unter [Nutzung verfolgen](https://platform.claude.com/docs/de/managed-agents/session-observability#track-usage).
## Budgets in Multiagent-Sitzungen
Eine [Multiagenten](https://platform.claude.com/docs/de/managed-agents/multiagent-orchestration)-Session hat ein einziges Budget, das von allen ihren Threads gemeinsam genutzt wird; es gibt keine Obergrenzen pro Thread. Der Verbrauch jedes Threads wird zu den Preisen seines eigenen verwendeten Modells berechnet, und Threads pausieren unabhängig voneinander, wenn die gemeinsame Obergrenze erreicht wird. Konsultationen des [Advisors](https://platform.claude.com/docs/de/managed-agents/multiagent-orchestration#give-the-session-an-advisor) werden auf dasselbe Budget angerechnet, bepreist zu den Tarifen des Advisor-Modells. Ein Thread kann mit `budget_reached` pausieren, während ein anderer seine laufende Anfrage abschließt.
Eine ausstehende Rückfrage hat Vorrang vor der Obergrenze: Eine Sitzung mit einem Thread, der auf `requires_action` wartet, und einem anderen, der bei `budget_reached` pausiert ist, meldet `requires_action` auf Sitzungsebene. Die ausstehende Anfrage braucht weiterhin eine Antwort, und sie zu beantworten ist ein [Abschluss-Event](https://platform.claude.com/docs/de/managed-agents/budgets#events-accepted-at-the-cap), das das Budget nicht blockiert.
## Budgets bei Deployments
Ein [Deployment](https://platform.claude.com/docs/de/managed-agents/scheduled-deployments) akzeptiert dasselbe `budget`-Objekt, wenn du es erstellst oder aktualisierst:
```json
{
"budget": {
"type": "limit",
"max_list_cost": { "amount": "2000", "currency": "USD" }
}
}
```
Die Obergrenze wird auf jede Sitzung kopiert, die das Deployment startet, sodass sie jede Ausführung einzeln begrenzt und nicht die kumulierten Ausgaben des Deployments. Eine Änderung des Budgets des Deployments gilt für Sitzungen, die das Deployment danach startet, nicht für bereits laufende Sitzungen. Anders als bei einer Sitzung kann das Budget eines Deployments mit `"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`) gelöscht und später erneut festgelegt werden. Siehe [Ein Budget für jede Ausführung festlegen](https://platform.claude.com/docs/de/managed-agents/scheduled-deployments#set-a-budget-on-each-run).
## Modelle ohne Listenpreis
Ein Budget kann nur Verbrauch erfassen, den die Plattform bepreisen kann. Das Erstellen einer Session mit Budget wird mit einem 400-Fehler abgelehnt, wenn eines der folgenden Elemente ein Modell ohne öffentlichen Listenpreis verwendet:
* Der Agent der Session
* Jeder Agent, der in der `predefined_agents` (java, php: `predefinedAgents`; csharp, go: `PredefinedAgents`)-Liste von `subagents` (csharp, go: `Subagents`) oder `workflows` (csharp, go: `Workflows`) aufgeführt ist
* Der Advisor, der in der [Multiagenten-Konfiguration](https://platform.claude.com/docs/de/managed-agents/multiagent-orchestration) des Agenten festgelegt ist
Die Fehlermeldung besagt, dass für das Modell kein Listenpreis verfügbar ist.
Wenn die Nutzung einer Sitzung mit Budget ein Modell ohne Listenpreis einschließt, kann das Budget die Ausgaben der Sitzung nicht mehr messen: Die Sitzung kann mit einem `stop_reason` (java, php: `stopReason`; csharp, go: `StopReason`) von `budget_reached` pausieren, und das Ändern des Budgets wird abgelehnt. Entferne das Budget, um die Sitzung fortzusetzen.
## Fehlerreferenz
Budgetbezogene Anfragen werden in den folgenden Fällen abgelehnt:
| Bedingung | Status |
| -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------ |
| Ein Arbeit startendes Event (zum Beispiel `user.message`) wird gesendet, während die Sitzung bei oder über ihrem Budget liegt; der Fehler nennt die [akzeptierten Abschluss-Events](https://platform.claude.com/docs/de/managed-agents/budgets#events-accepted-at-the-cap) | 400 |
| Das Budget wird auf einen Wert bei oder unter den verbrauchten Listenkosten der Sitzung gesetzt | 400 |
| Ein Budget wird einer ohne Budget erstellten Sitzung hinzugefügt oder nach dem Entfernen erneut hinzugefügt | 400 |
| `amount` (csharp, go: `Amount`) ist keine ganze Zahl von Cent (zum Beispiel `"25.00"`), ist null oder negativ, oder `currency` (csharp, go: `Currency`) ist nicht `USD` | 400 |
| Eine budgetierte Erstellung referenziert ein Modell [ohne öffentlichen Listenpreis](https://platform.claude.com/docs/de/managed-agents/budgets#models-without-a-list-price) | 400 |
Sitzungsbudgets sind harte Obergrenzen in US-Dollar (in Cent geschrieben) für eine einzelne Sitzung, die von der Plattform durchgesetzt werden. Sie unterscheiden sich von den [Task-Budgets](https://platform.claude.com/docs/de/build-with-claude/task-budgets) der Messages API, die beratende, in Token bemessene Budgets sind, die das Modell zur Selbstregulierung innerhalb einer agentischen Schleife verwendet.
## Verfügbarkeit
Sitzungsbudgets sind auf allen Modellen in der Beta.
### API-Unterstützung
#### [Messages API](https://platform.claude.com/docs/de/build-with-claude/working-with-messages)
* Verfügbarkeit: Nicht verfügbar
* Nutzung: Verwende stattdessen [Task-Budgets](https://platform.claude.com/docs/de/build-with-claude/task-budgets).
#### [Managed Agents](https://platform.claude.com/docs/de/managed-agents/overview)
* Verfügbarkeit: Verfügbar
| Status | Cloud-Plattformen |
| ------ | ------------------------------ |
| Beta | Alle unterstützten Plattformen |
### Erforderliche Beta-Header
[Übersicht über Beta-Header](https://platform.claude.com/docs/de/api/beta-headers)
Mit Beta-Headern kannst du auf experimentelle Funktionen und neue Modellfähigkeiten zugreifen, bevor sie Teil der Standard-API werden.
* `managed-agents-2026-04-01`
### Datenverarbeitung
[Übersicht über die Datenverarbeitung](https://platform.claude.com/docs/de/manage-claude/api-and-data-retention#feature-eligibility)
| Element | Zero Data Retention | HIPAA |
| ------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ----------------------------------------------------------------------------- |
| Status | Nicht berechtigt | Nicht berechtigt |
| Details | Nicht für ZDR berechtigt, außer bei selbst gehosteten Managed Agents. Sitzungen sind zustandsbehaftete Ressourcen; Transkripte bleiben erhalten, bis du sie löschst. [Mehr erfahren](https://platform.claude.com/docs/de/managed-agents/self-hosted-data-and-access#how-long-data-is-kept) | Nicht für HIPAA berechtigt. Gilt für alle Unterfunktionen von Managed Agents. |
Zutreffende Endpunkte:
* `/v1/agents`
* `/v1/sessions`
* `/v1/environments`