---
title: Session-Operationen
url: https://platform.claude.com/docs/de/managed-agents/session-operations
description: Sessions von Claude Managed Agents abrufen, auflisten, aktualisieren, archivieren und löschen.
featureMetadata:
  topic:
    title: Managed Agents
    url: https://platform.claude.com/docs/en/managed-agents/overview
  status: beta
  betaHeader: managed-agents-2026-04-01
---

Sobald eine Session existiert, verwende diese Operationen, um sie zu lesen, zu aktualisieren, zu archivieren oder zu löschen. Siehe [Eine Session starten](https://platform.claude.com/docs/de/managed-agents/sessions) zum Erstellen einer Session und zum Senden von Arbeit an sie.

## Session-Status

Sessions durchlaufen diese Status. Siehe [Eine Session starten](https://platform.claude.com/docs/de/managed-agents/sessions) für den Session-Lebenszyklus.

| Status         | Beschreibung                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| -------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `idle`         | Der Agent wartet auf Eingaben, einschließlich Benutzernachrichten oder Tool-Bestätigungen. Sessions, die ohne `initial_events` (java, php: `initialEvents`; csharp, go: `InitialEvents`) erstellt werden, starten im Status `idle`. Eine Session kann `idle` sein, während ein [Workflow-Run](https://platform.claude.com/docs/de/managed-agents/workflow-runs#while-a-run-is-open) noch offen ist, daher bedeutet `idle` allein nicht, dass die Arbeit erledigt ist. Siehe [Erkennen, wann die Arbeit erledigt ist](https://platform.claude.com/docs/de/managed-agents/workflow-runs#know-when-the-work-is-done). |
| `running`      | Der Agent führt aktiv aus.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| `rescheduling` | Ein vorübergehender Fehler ist aufgetreten, es wird automatisch erneut versucht.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| `terminated`   | Die Session wurde beendet, entweder aufgrund eines nicht behebbaren Fehlers oder weil sie archiviert wurde. Eine Session, die ihre Arbeit abschließt, wechselt zu `idle`, nicht zu `terminated`.                                                                                                                                                                                                                                                                                                                                                                                                                   |

## Aktualisieren der Agent-Konfiguration

Du kannst `agent.tools` (csharp, go: `Agent.Tools`) und `agent.mcp_servers` (java, php: `agent.mcpServers`; csharp: `Agent.McpServers`; go: `Agent.MCPServers`) einer Session, einschließlich Berechtigungsrichtlinien und Web-Einstellungen pro Tool wie [Domain-Filtern](https://platform.claude.com/docs/de/managed-agents/tools-web-restrictions#change-the-lists-mid-session), während der laufenden Session aktualisieren, ohne eine neue Agent-Version zu erstellen. Aktualisierungen gelten nur lokal für die Session und werden nicht an den zugrunde liegenden Agent zurückübertragen. Aktualisierte `allowed_domains` (java, php: `allowedDomains`; csharp, go: `AllowedDomains`) und `blocked_domains` (java, php: `blockedDomains`; csharp, go: `BlockedDomains`) gelten für den Rest der Session.

Nur `tools` (csharp, go: `Tools`) und `mcp_servers` (java, php: `mcpServers`; csharp: `McpServers`; go: `MCPServers`) des Agents können nach dem Erstellen einer Session geändert werden. Um eine Session mit anderen Werten für `model` (csharp, go: `Model`), `system` (csharp, go: `System`; ruby: `system_`) oder `skills` (csharp, go: `Skills`) als denen des Agents auszuführen, verwende beim Erstellen der Session [Überschreibungen der Agent-Konfiguration](https://platform.claude.com/docs/de/managed-agents/sessions#override-agent-configuration-for-a-session). Auch die Modellkonfiguration des Agents, einschließlich seiner [`inference_geo`](https://platform.claude.com/docs/de/manage-claude/data-residency)-Festlegung, kann während der Session nicht geändert werden: Setze die Festlegung, wenn du den Agent speicherst, oder setze bzw. entferne sie für eine einzelne Session mit einer `model` (csharp, go: `Model`)-Überschreibung beim Erstellen der Session. Das konfigurierte Feld `system` (csharp, go: `System`; ruby: `system_`) des Agents ist für die gesamte Lebensdauer der Session festgelegt. Bei Modellen, die dies unterstützen, kannst du während der Session dennoch Anweisungen auf Systemebene anhängen, indem du ein [`system.message`-Event](https://platform.claude.com/docs/de/managed-agents/events-and-streaming#send-system-messages) sendest.

Eine Aktualisierung von `tools` (csharp, go: `Tools`) oder `mcp_servers` (java, php: `mcpServers`; csharp: `McpServers`; go: `MCPServers`) ersetzt den Wert vollständig: Das übergebene Array ist der neue Wert. Um bestehende Einträge beizubehalten, rufe die Session per `GET` ab, ändere das Array und sende es per `POST` zurück.

Die Session muss `idle` sein, um den Agent zu aktualisieren. Um den Agent zu aktualisieren, während die Session läuft, sende ein [`user.interrupt`-Event](https://platform.claude.com/docs/de/managed-agents/events-and-streaming#interrupt-the-agent) für sich allein und warte, bis die Session `idle` wird. Wenn ein [Workflow-Run](https://platform.claude.com/docs/de/managed-agents/workflow-runs#while-a-run-is-open) offen ist, egal ob er läuft oder pausiert ist, gibt die Aktualisierung einen 400-Fehler zurück, selbst wenn die Session `idle` ist. Eine Unterbrechung beendet keinen Run, daher schlägt die Aktualisierung auch nach dem Unterbrechen der Session fehl. Sende eine `user.message`, die [den Agent auffordert, seine Runs zu stoppen](https://platform.claude.com/docs/de/managed-agents/workflow-runs#interrupt-a-session-with-runs-open), oder warte, bis jeder Run beendet ist.

<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 '{
      "agent": {
        "tools": [
          {"type": "agent_toolset_20260401"},
          {"type": "mcp_toolset", "mcp_server_name": "linear"}
        ],
        "mcp_servers": [
          {"type": "url", "name": "linear", "url": "https://mcp.linear.app/sse"}
        ]
      }
    }'
  ```

  ```bash CLI
  ant beta:sessions update --session-id "$SESSION_ID" <<'YAML'
  agent:
    tools:
      - type: agent_toolset_20260401
      - type: mcp_toolset
        mcp_server_name: linear
    mcp_servers:
      - type: url
        name: linear
        url: https://mcp.linear.app/sse
  YAML
  ```

  ```python Python
  client.beta.sessions.update(
      session.id,
      agent={
          "tools": [
              {"type": "agent_toolset_20260401"},
              {"type": "mcp_toolset", "mcp_server_name": "linear"},
          ],
          "mcp_servers": [
              {"type": "url", "name": "linear", "url": "https://mcp.linear.app/sse"}
          ],
      },
  )
  ```

  ```typescript TypeScript
  await client.beta.sessions.update(session.id, {
    agent: {
      tools: [
        { type: "agent_toolset_20260401" },
        { type: "mcp_toolset", mcp_server_name: "linear" }
      ],
      mcp_servers: [{ type: "url", name: "linear", url: "https://mcp.linear.app/sse" }]
    }
  });
  ```

  ```csharp C#
  await client.Beta.Sessions.Update(session.ID, new()
  {
      Agent = new()
      {
          Tools =
          [
              new BetaManagedAgentsAgentToolset20260401Params
              {
                  Type = BetaManagedAgentsAgentToolset20260401ParamsType.AgentToolset20260401,
              },
              new BetaManagedAgentsMcpToolsetParams
              {
                  Type = BetaManagedAgentsMcpToolsetParamsType.McpToolset,
                  McpServerName = "linear",
              },
          ],
          McpServers =
          [
              new()
              {
                  Type = BetaManagedAgentsUrlMcpServerParamsType.Url,
                  Name = "linear",
                  Url = "https://mcp.linear.app/sse",
              },
          ],
      },
  });
  ```

  ```go Go
  _, err = client.Beta.Sessions.Update(ctx, session.ID, anthropic.BetaSessionUpdateParams{
  	Agent: anthropic.BetaManagedAgentsSessionAgentUpdateParam{
  		Tools: []anthropic.BetaManagedAgentsSessionAgentUpdateToolUnionParam{
  			{
  				OfAgentToolset20260401: &anthropic.BetaManagedAgentsAgentToolset20260401Params{
  					Type: anthropic.BetaManagedAgentsAgentToolset20260401ParamsTypeAgentToolset20260401,
  				},
  			},
  			{
  				OfMCPToolset: &anthropic.BetaManagedAgentsMCPToolsetParams{
  					Type:          anthropic.BetaManagedAgentsMCPToolsetParamsTypeMCPToolset,
  					MCPServerName: "linear",
  				},
  			},
  		},
  		MCPServers: []anthropic.BetaManagedAgentsURLMCPServerParams{
  			{
  				Type: anthropic.BetaManagedAgentsURLMCPServerParamsTypeURL,
  				Name: "linear",
  				URL:  "https://mcp.linear.app/sse",
  			},
  		},
  	},
  })
  if err != nil {
  	panic(err)
  }
  ```

  ```java Java
  client.beta().sessions().update(
      session.id(),
      SessionUpdateParams.builder()
          .agent(BetaManagedAgentsSessionAgentUpdate.builder()
              .addTool(BetaManagedAgentsAgentToolset20260401Params.builder()
                  .type(BetaManagedAgentsAgentToolset20260401Params.Type.AGENT_TOOLSET_20260401)
                  .build())
              .addTool(BetaManagedAgentsMcpToolsetParams.builder()
                  .type(BetaManagedAgentsMcpToolsetParams.Type.MCP_TOOLSET)
                  .mcpServerName("linear")
                  .build())
              .addMcpServer(BetaManagedAgentsUrlMcpServerParams.builder()
                  .type(BetaManagedAgentsUrlMcpServerParams.Type.URL)
                  .name("linear")
                  .url("https://mcp.linear.app/sse")
                  .build())
              .build())
          .build()
  );
  ```

  ```php PHP
  $client->beta->sessions->update(
      $session->id,
      agent: BetaManagedAgentsSessionAgentUpdate::with(
          tools: [
              BetaManagedAgentsAgentToolset20260401Params::with(type: 'agent_toolset_20260401'),
              BetaManagedAgentsMCPToolsetParams::with(mcpServerName: 'linear', type: 'mcp_toolset'),
          ],
          mcpServers: [
              BetaManagedAgentsURLMCPServerParams::with(
                  name: 'linear',
                  type: 'url',
                  url: 'https://mcp.linear.app/sse',
              ),
          ],
      ),
  );
  ```

  ```ruby Ruby
  client.beta.sessions.update(
    session.id,
    agent: {
      tools: [
        {type: :agent_toolset_20260401},
        {type: :mcp_toolset, mcp_server_name: "linear"}
      ],
      mcp_servers: [
        {type: :url, name: "linear", url: "https://mcp.linear.app/sse"}
      ]
    }
  )
  ```
</CodeGroup>

## Aktualisieren des Session-Budgets

Eine [mit einem Budget erstellte](https://platform.claude.com/docs/de/managed-agents/sessions#set-a-session-budget) Session akzeptiert zwei Arten von Budget-Aktualisierungen: das Ersetzen der Obergrenze durch ein neues `max_list_cost` (java, php: `maxListCost`; csharp, go: `MaxListCost`) und das Entfernen durch Übergabe von `"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`). Beide setzen Arbeit, die pausiert wurde, als die Session ihre Obergrenze erreicht hat, automatisch fort. Eine neue Obergrenze kann höher oder niedriger als die aktuelle sein, muss aber strikt größer als die bereits verbrauchten Listenkosten der Session sein, und das Entfernen ist endgültig: Ein `budget` (csharp, go: `Budget`) ungleich null wird nur bei einer Session akzeptiert, die aktuell eines hat, sodass du ein entferntes Budget nicht erneut hinzufügen und auch keines zu einer ohne Budget erstellten Session hinzufügen kannst. Unter [Session-Budgets](https://platform.claude.com/docs/de/managed-agents/budgets#resume-a-session-at-its-budget) findest du Anfragebeispiele, das Fehlerverhalten und was zu den Listenkosten zählt.

## Abrufen einer Session

<CodeGroup>
  ```bash cURL
  curl -fsSL "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"
  ```

  ```bash CLI
  ant beta:sessions retrieve --session-id "$SESSION_ID"
  ```

  ```python Python
  retrieved = client.beta.sessions.retrieve(session.id)
  print(f"Status: {retrieved.status}")
  ```

  ```typescript TypeScript
  const retrieved = await client.beta.sessions.retrieve(session.id);
  console.log(`Status: ${retrieved.status}`);
  ```

  ```csharp C#
  var retrieved = await client.Beta.Sessions.Retrieve(session.ID);
  Console.WriteLine($"Status: {retrieved.Status.Raw()}");
  ```

  ```go Go
  retrieved, err := client.Beta.Sessions.Get(ctx, session.ID, anthropic.BetaSessionGetParams{})
  if err != nil {
  	panic(err)
  }
  fmt.Printf("Status: %s\n", retrieved.Status)
  ```

  ```java Java
  var retrieved = client.beta().sessions().retrieve(session.id());
  IO.println("Status: " + retrieved.status());
  ```

  ```php PHP
  $retrieved = $client->beta->sessions->retrieve($session->id);
  echo "Status: {$retrieved->status}\n";
  ```

  ```ruby Ruby
  retrieved = client.beta.sessions.retrieve(session.id)
  puts "Status: #{retrieved.status}"
  ```
</CodeGroup>

## Auflisten von Sessions

Ergebnisse von `GET /v1/sessions` sind paginiert. Verwende den Query-Parameter `limit`, um die Seitengröße zu steuern. Jede Antwort enthält einen `next_page`-Cursor; übergib ihn als `page`-Parameter bei der nächsten Anfrage, um die folgende Seite abzurufen. `next_page` ist `null`, wenn es keine weiteren Ergebnisse gibt.

Um eine Seite zurückzugehen, übergib `prev_page` als `page`-Parameter. `prev_page` ist `null`, wenn du dich auf der ersten Seite befindest.

Ein `page`-Cursor ist opak und kodiert die `order` der Anfrage, die ihn erzeugt hat. Der Query-Parameter `order` legt die Sortierrichtung der Ergebnisse fest, `asc` oder `desc` nach Erstellungszeit; der Standard ist `desc` (neueste zuerst). Die Wiederverwendung eines Cursors mit einer anderen `order` gibt einen 400-Fehler zurück, ebenso wie das Ändern eines `created_at`-Filters, sodass er die Position des Cursors ausschließt. Andere Query-Parameter, einschließlich der übrigen Filter und `limit`, können sich zwischen paginierten Anfragen ändern. Zu den Paginierungsfeldern, die alle List-Endpunkte gemeinsam haben, siehe [Paginierung](https://platform.claude.com/docs/de/api/overview#pagination).

<CodeGroup>
  ```bash cURL
  curl -sS --fail-with-body \
    "https://api.anthropic.com/v1/sessions?agent_id=$AGENT_ID&limit=1" \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "anthropic-beta: managed-agents-2026-04-01"
  # Pass next_page back as the page query parameter to fetch the next page,
  # or prev_page to go back.
  ```

  ```bash CLI
  # --format raw returns one page envelope with its prev_page and next_page
  # cursors; the default output auto-paginates and emits only the sessions.
  ant beta:sessions list \
    --agent-id "$AGENT_ID" \
    --limit 1 \
    --format raw
  # Pass next_page back as --page to fetch the next page, or prev_page to go back.
  ```

  ```python Python
  # Setze `limit` niedrig, damit sich die Ergebnisse über mehr als eine Seite erstrecken.
  first_page = client.beta.sessions.list(limit=1, agent_id=agent.id)
  # `prev_page` ist None auf der ersten Seite; `next_page` ist None auf der letzten.
  print(f"prev_page: {first_page.prev_page}")
  print(f"next_page: {first_page.next_page}")

  # Übergib `next_page` als `page`, um die nächste Seite abzurufen.
  second_page = client.beta.sessions.list(
      limit=1, agent_id=agent.id, page=first_page.next_page
  )
  for listed_session in second_page.data:
      print(f"{listed_session.id}: {listed_session.status}")

  # Übergib `prev_page` als `page`, um zur vorherigen Seite zurückzukehren.
  previous_page = client.beta.sessions.list(
      limit=1, agent_id=agent.id, page=second_page.prev_page
  )
  for listed_session in previous_page.data:
      print(f"{listed_session.id}: {listed_session.status}")
  # Für reine Vorwärts-Iteration ist das Page-Objekt auch direkt iterierbar.
  ```

  ```typescript TypeScript
  const firstPage = await client.beta.sessions.list({ limit: 1, agent_id: agent.id });
  // prev_page ist auf der ersten Seite null; next_page ist gesetzt, wenn weitere Sessions existieren.
  console.log(`prev_page: ${firstPage.prev_page}`);
  console.log(`next_page: ${firstPage.next_page}`);

  // Übergib next_page als `page`-Cursor, um die zweite Seite abzurufen.
  const secondPage = await client.beta.sessions.list({
    limit: 1,
    agent_id: agent.id,
    page: firstPage.next_page
  });
  for (const listedSession of secondPage.data) {
    console.log(`Page 2 has ${listedSession.id}: ${listedSession.status}`);
  }

  // Übergib den prev_page-Cursor der zweiten Seite, um zur ersten Seite zurückzugehen.
  const previousPage = await client.beta.sessions.list({
    limit: 1,
    agent_id: agent.id,
    page: secondPage.prev_page
  });
  for (const listedSession of previousPage.data) {
    console.log(`Back on page 1: ${listedSession.id} is ${listedSession.status}`);
  }
  // Für reine Vorwärts-Iteration ist das Page-Objekt auch direkt iterierbar.
  ```

  ```csharp C#
  // Die SessionListPage, die `List` zurückgibt, stellt die Items bereit, aber nicht die
  // Paginierungs-Cursor. Um `prev_page` / `next_page` zu lesen, deserialisiere die rohe
  // Antwort stattdessen in SessionListPageResponse.
  using var page1Response = await client.Beta.Sessions.WithRawResponse.List(
      new SessionListParams { Limit = 1, AgentID = agent.ID }
  );
  var page1 = await page1Response.Deserialize<SessionListPageResponse>();
  Console.WriteLine($"prev_page: {page1.PrevPage ?? "null"}");
  Console.WriteLine($"next_page: {page1.NextPage ?? "null"}");

  // Vorwärts: übergib `next_page` von Seite 1 als `page`-Cursor.
  using var page2Response = await client.Beta.Sessions.WithRawResponse.List(
      new SessionListParams { Limit = 1, AgentID = agent.ID, Page = page1.NextPage }
  );
  var page2 = await page2Response.Deserialize<SessionListPageResponse>();
  foreach (var listedSession in page2.Data ?? [])
  {
      Console.WriteLine($"Page 2: {listedSession.ID}: {listedSession.Status.Raw()}");
  }

  // Zurück: übergib `prev_page` von Seite 2 als denselben `page`-Cursor.
  using var previousPageResponse = await client.Beta.Sessions.WithRawResponse.List(
      new SessionListParams { Limit = 1, AgentID = agent.ID, Page = page2.PrevPage }
  );
  var previousPage = await previousPageResponse.Deserialize<SessionListPageResponse>();
  foreach (var listedSession in previousPage.Data ?? [])
  {
      Console.WriteLine($"Back to page 1: {listedSession.ID}: {listedSession.Status.Raw()}");
  }
  // Für reine Vorwärts-Iteration gibt (await client.Beta.Sessions.List(...)).Paginate() ein IAsyncEnumerable zurück, das next_page automatisch folgt.
  ```

  ```go Go
  // Seite 1: prev_page ist leer, weil der ersten Seite nichts vorausgeht.
  firstPage, err := client.Beta.Sessions.List(ctx, anthropic.BetaSessionListParams{
  	AgentID: anthropic.String(agent.ID),
  	Limit:   anthropic.Int(1),
  })
  if err != nil {
  	panic(err)
  }
  fmt.Printf("Page 1 prev_page: %q\n", firstPage.PrevPage)
  fmt.Printf("Page 1 next_page: %q\n", firstPage.NextPage)

  // Weiter: übergib next_page als Page-Cursor, um Seite 2 abzurufen.
  secondPage, err := client.Beta.Sessions.List(ctx, anthropic.BetaSessionListParams{
  	AgentID: anthropic.String(agent.ID),
  	Limit:   anthropic.Int(1),
  	Page:    anthropic.String(firstPage.NextPage),
  })
  if err != nil {
  	panic(err)
  }
  for _, listedSession := range secondPage.Data {
  	fmt.Printf("Page 2: %s: %s\n", listedSession.ID, listedSession.Status)
  }

  // Zurück: prev_page von Seite 2 ist der Cursor für die Seite davor.
  previousPage, err := client.Beta.Sessions.List(ctx, anthropic.BetaSessionListParams{
  	AgentID: anthropic.String(agent.ID),
  	Limit:   anthropic.Int(1),
  	Page:    anthropic.String(secondPage.PrevPage),
  })
  if err != nil {
  	panic(err)
  }
  for _, listedSession := range previousPage.Data {
  	fmt.Printf("Back to page 1: %s: %s\n", listedSession.ID, listedSession.Status)
  }
  // Für reine Vorwärts-Iteration verwende ListAutoPaging, das next_page automatisch folgt.
  ```

  ```java Java
  var params = SessionListParams.builder()
      .agentId(agent.id())
      .limit(1)
      .build();
  var firstPage = client.beta().sessions().list(params);
  for (var listedSession : firstPage.data()) {
      IO.println(listedSession.id() + ": " + listedSession.status());
  }
  // prev_page ist auf der ersten Seite ein leeres Optional; next_page zeigt auf Seite 2.
  IO.println("prev_page: " + firstPage.response().prevPage());
  IO.println("next_page: " + firstPage.response().nextPage());

  // Gehe vorwärts, indem du next_page als Seiten-Cursor übergibst.
  var nextCursor = firstPage.response().nextPage().orElseThrow();
  var secondPage = client.beta().sessions().list(params.toBuilder().page(nextCursor).build());

  // Gehe zurück, indem du prev_page als denselben Seiten-Cursor übergibst.
  var prevCursor = secondPage.response().prevPage().orElseThrow();
  var previousPage = client.beta().sessions().list(params.toBuilder().page(prevCursor).build());
  // Wieder auf der ersten Seite, daher ist prev_page wieder leer.
  IO.println("prev_page: " + previousPage.response().prevPage());
  // Für reine Vorwärts-Iteration gibt page.autoPager() ein Iterable zurück, das next_page automatisch folgt.
  ```

  ```php PHP
  // Seite 1: prevPage ist null, weil der ersten Seite nichts vorausgeht.
  $firstPage = $client->beta->sessions->list(agentID: $agent->id, limit: 1);
  echo 'Page 1 prev_page: ' . ($firstPage->prevPage ?? 'null') . "\n";
  echo 'Page 1 next_page: ' . ($firstPage->nextPage ?? 'null') . "\n";

  // Weiter: Übergib nextPage als `page`-Cursor, um Seite 2 abzurufen.
  $secondPage = $client->beta->sessions->list(
      agentID: $agent->id,
      limit: 1,
      page: $firstPage->nextPage,
  );
  foreach ($secondPage->getItems() as $listedSession) {
      echo "Page 2: {$listedSession->id}: {$listedSession->status}\n";
  }

  // Zurück: prevPage von Seite 2 ist der Cursor für die Seite davor.
  $previousPage = $client->beta->sessions->list(
      agentID: $agent->id,
      limit: 1,
      page: $secondPage->prevPage,
  );
  foreach ($previousPage->getItems() as $listedSession) {
      echo "Back to page 1: {$listedSession->id}: {$listedSession->status}\n";
  }
  // Für reine Vorwärts-Iteration liefert $page->pagingEachItem() jede Session über alle Seiten hinweg.
  ```

  ```ruby Ruby
  first_page = client.beta.sessions.list(agent_id: agent.id, limit: 1)
  first_page.data.each do |listed_session|
    puts "#{listed_session.id}: #{listed_session.status}"
  end

  # `prev_page` ist auf der ersten Seite nil. Der Cursor für die nächste Seite heißt
  # `next_page_` (mit Unterstrich am Ende), weil das einfache `next_page` die Helper-
  # Methode ist, die das nächste Seitenobjekt für dich abruft.
  puts "prev_page: #{first_page.prev_page.inspect}"
  puts "next_page: #{first_page.next_page_.inspect}"

  # Übergib einen der beiden Cursor als `page`, um die Liste in beide Richtungen zu durchlaufen.
  second_page = client.beta.sessions.list(
    agent_id: agent.id,
    limit: 1,
    page: first_page.next_page_
  )
  back_to_first = client.beta.sessions.list(
    agent_id: agent.id,
    limit: 1,
    page: second_page.prev_page
  )
  back_to_first.data.each do |listed_session|
    puts "#{listed_session.id}: #{listed_session.status}"
  end
  # Für reine Vorwärts-Iteration folgt page.auto_paging_each automatisch next_page.
  ```
</CodeGroup>

## Archivieren einer Session

Archiviere eine Session, um zu verhindern, dass neue Events gesendet werden, während ihr Verlauf erhalten bleibt. Eine Session im Status `running` kann nicht archiviert werden; um sie zu archivieren, sende ein [`user.interrupt`-Event](https://platform.claude.com/docs/de/managed-agents/events-and-streaming#interrupt-the-agent) für sich allein und warte, bis die Session `idle` wird. Wenn ein [Workflow-Run](https://platform.claude.com/docs/de/managed-agents/workflow-runs#while-a-run-is-open) offen ist, kann das Archivieren einen 400-Fehler zurückgeben, selbst wenn die Session `idle` ist, oder es kann erfolgreich sein und den Run beenden. Sende vor dem Archivieren eine `user.message`, die [den Agent auffordert, seine Runs zu stoppen](https://platform.claude.com/docs/de/managed-agents/workflow-runs#interrupt-a-session-with-runs-open), oder warte, bis jeder Run beendet ist. Archiviere die Session dann, sobald sie `idle` ist.

<CodeGroup>
  ```bash cURL
  curl -fsSL -X POST "https://api.anthropic.com/v1/sessions/$SESSION_ID/archive" \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "anthropic-beta: managed-agents-2026-04-01"
  ```

  ```bash CLI
  ant beta:sessions archive \
    --session-id "$SESSION_ID"
  ```

  ```python Python
  client.beta.sessions.archive(session.id)
  ```

  ```typescript TypeScript
  await client.beta.sessions.archive(session.id);
  ```

  ```csharp C#
  await client.Beta.Sessions.Archive(session.ID);
  ```

  ```go Go
  _, err = client.Beta.Sessions.Archive(ctx, session.ID, anthropic.BetaSessionArchiveParams{})
  if err != nil {
  	panic(err)
  }
  ```

  ```java Java
  client.beta().sessions().archive(session.id());
  ```

  ```php PHP
  $client->beta->sessions->archive($session->id);
  ```

  ```ruby Ruby
  client.beta.sessions.archive(session.id)
  ```
</CodeGroup>

## Löschen einer Session

Lösche eine Session, um ihren Datensatz, ihre Events und die zugehörige Sandbox dauerhaft zu entfernen. Eine Session im Status `running` kann nicht gelöscht werden; um sie zu löschen, sende ein [`user.interrupt`-Event](https://platform.claude.com/docs/de/managed-agents/events-and-streaming#interrupt-the-agent) für sich allein und warte, bis die Session `idle` wird. Wenn ein [Workflow-Run](https://platform.claude.com/docs/de/managed-agents/workflow-runs#while-a-run-is-open) offen ist, kann das Löschen einen 400-Fehler zurückgeben, selbst wenn die Session `idle` ist, oder es kann erfolgreich sein. Nach einem erfolgreichen Löschen meldet kein `workflow_run`-Event das Ende der Runs der Session. Sende vor dem Löschen eine `user.message`, die [den Agent auffordert, seine Runs zu stoppen](https://platform.claude.com/docs/de/managed-agents/workflow-runs#interrupt-a-session-with-runs-open), oder warte, bis jeder Run beendet ist. Lösche die Session dann, sobald sie `idle` ist.

Memory Stores, Vaults, Skills, Umgebungen und Agents sind unabhängige Ressourcen und werden vom Löschen einer Session nicht beeinflusst. Dateien, die du über die Files API hochgeladen hast, bleiben ebenfalls unberührt, aber Dateien, die die Session selbst erzeugt hat, sind auf sie beschränkt und werden zusammen mit ihrem Dateisystem dauerhaft gelöscht. Lade alles herunter, was du behalten möchtest, bevor du die Session löschst. Eine Ausgabedatei, die am Ende des letzten Turns geschrieben wurde, kann einige Sekunden, nachdem die Session zu idle gewechselt ist, benötigen, bis sie in der [Dateiliste der Session](https://platform.claude.com/docs/de/managed-agents/files#listing-and-downloading-session-files) erscheint. Prüfe daher zuerst, ob die erwarteten Dateien aufgelistet sind.

<CodeGroup>
  ```bash cURL
  curl -fsSL -X DELETE "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"
  ```

  ```bash CLI
  ant beta:sessions delete \
    --session-id "$SESSION_ID"
  ```

  ```python Python
  client.beta.sessions.delete(session.id)
  ```

  ```typescript TypeScript
  await client.beta.sessions.delete(session.id);
  ```

  ```csharp C#
  await client.Beta.Sessions.Delete(session.ID);
  ```

  ```go Go
  _, err = client.Beta.Sessions.Delete(ctx, session.ID, anthropic.BetaSessionDeleteParams{})
  if err != nil {
  	panic(err)
  }
  ```

  ```java Java
  client.beta().sessions().delete(session.id());
  ```

  ```php PHP
  $client->beta->sessions->delete($session->id);
  ```

  ```ruby Ruby
  client.beta.sessions.delete(session.id)
  ```
</CodeGroup>