---
title: Opérations sur les sessions
url: https://platform.claude.com/docs/fr/managed-agents/session-operations
description: Récupérez, listez, mettez à jour, archivez et supprimez des sessions Claude Managed Agents.
featureMetadata:
  topic:
    title: Managed Agents
    url: https://platform.claude.com/docs/en/managed-agents/overview
  status: beta
  betaHeader: managed-agents-2026-04-01
---

Une fois qu'une session existe, utilisez ces opérations pour la lire, la mettre à jour, l'archiver ou la supprimer. Consultez [Démarrer une session](https://platform.claude.com/docs/fr/managed-agents/sessions) pour créer une session et lui envoyer du travail.

## Statuts de session

Les sessions progressent à travers ces statuts. Consultez [Démarrer une session](https://platform.claude.com/docs/fr/managed-agents/sessions) pour le cycle de vie d'une session.

| Statut         | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| -------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `idle`         | L'agent attend une entrée, y compris des messages utilisateur ou des confirmations d'outils. Les sessions créées sans `initial_events` (java, php: `initialEvents`; csharp, go: `InitialEvents`) démarrent à l'état `idle`. Une session peut être `idle` alors qu'une [exécution de workflow](https://platform.claude.com/docs/fr/managed-agents/workflow-runs#while-a-run-is-open) est encore ouverte, donc `idle` seul ne signifie pas que le travail est terminé. Consultez [Savoir quand le travail est terminé](https://platform.claude.com/docs/fr/managed-agents/workflow-runs#know-when-the-work-is-done). |
| `running`      | L'agent est en cours d'exécution active.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| `rescheduling` | Une erreur transitoire s'est produite, nouvelle tentative automatique en cours.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| `terminated`   | La session s'est terminée, soit en raison d'une erreur irrécupérable, soit parce qu'elle a été archivée. Une session qui termine son travail passe à l'état `idle`, et non `terminated`.                                                                                                                                                                                                                                                                                                                                                                                                                           |

## Mise à jour de la configuration de l'agent

Vous pouvez mettre à jour les champs `agent.tools` (csharp, go: `Agent.Tools`) et `agent.mcp_servers` (java, php: `agent.mcpServers`; csharp: `Agent.McpServers`; go: `Agent.MCPServers`) d'une session, y compris les politiques d'autorisation et les paramètres web par outil tels que les [filtres de domaine](https://platform.claude.com/docs/fr/managed-agents/tools-web-restrictions#change-the-lists-mid-session), en cours de session sans créer de nouvelle version de l'agent. Les mises à jour sont locales à la session et ne se propagent pas à l'agent sous-jacent. Les valeurs mises à jour de `allowed_domains` (java, php: `allowedDomains`; csharp, go: `AllowedDomains`) et `blocked_domains` (java, php: `blockedDomains`; csharp, go: `BlockedDomains`) s'appliquent pour le reste de la session.

Seuls les champs `tools` (csharp, go: `Tools`) et `mcp_servers` (java, php: `mcpServers`; csharp: `McpServers`; go: `MCPServers`) de l'agent peuvent changer après la création d'une session. Pour exécuter une session avec des valeurs de `model` (csharp, go: `Model`), `system` (csharp, go: `System`; ruby: `system_`) ou `skills` (csharp, go: `Skills`) différentes de celles de l'agent, utilisez les [remplacements de configuration de l'agent](https://platform.claude.com/docs/fr/managed-agents/sessions#override-agent-configuration-for-a-session) lors de la création de la session. La configuration du modèle de l'agent, y compris son épinglage [`inference_geo`](https://platform.claude.com/docs/fr/manage-claude/data-residency), ne peut pas non plus changer en cours de session : définissez l'épinglage lorsque vous enregistrez l'agent, ou définissez-le ou supprimez-le pour une seule session avec un remplacement de `model` (csharp, go: `Model`) lors de sa création. Le champ `system` (csharp, go: `System`; ruby: `system_`) configuré de l'agent est fixe pendant toute la durée de vie de la session. Sur les modèles qui le prennent en charge, vous pouvez tout de même ajouter des instructions de niveau système en cours de session en envoyant un [événement `system.message`](https://platform.claude.com/docs/fr/managed-agents/events-and-streaming#send-system-messages).

La sémantique d'une mise à jour de `tools` (csharp, go: `Tools`) ou de `mcp_servers` (java, php: `mcpServers`; csharp: `McpServers`; go: `MCPServers`) est un remplacement complet : le tableau fourni devient la nouvelle valeur. Pour conserver les entrées existantes, effectuez un `GET` sur la session, modifiez le tableau, puis renvoyez-le avec un `POST`.

La session doit être `idle` pour mettre à jour l'agent. Pour mettre à jour l'agent pendant que la session est en cours d'exécution, envoyez un [événement `user.interrupt`](https://platform.claude.com/docs/fr/managed-agents/events-and-streaming#interrupt-the-agent) seul et attendez que la session devienne `idle`. Si une [exécution de workflow](https://platform.claude.com/docs/fr/managed-agents/workflow-runs#while-a-run-is-open) est ouverte, qu'elle soit en cours ou en pause, la mise à jour renvoie une erreur 400, même lorsque la session est `idle`. Une interruption ne met pas fin à une exécution ; la mise à jour échoue donc toujours après l'interruption de la session. Envoyez un `user.message` qui [demande à l'agent d'arrêter ses exécutions](https://platform.claude.com/docs/fr/managed-agents/workflow-runs#interrupt-a-session-with-runs-open), ou attendez que toutes les exécutions soient terminées.

<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>

## Mise à jour du budget de la session

Une session [créée avec un budget](https://platform.claude.com/docs/fr/managed-agents/sessions#set-a-session-budget) accepte deux types de mise à jour du budget : le remplacement du plafond par un nouveau `max_list_cost` (java, php: `maxListCost`; csharp, go: `MaxListCost`), et sa suppression en passant `"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`). Les deux reprennent automatiquement le travail mis en pause lorsque la session a atteint son plafond. Un plafond de remplacement peut être supérieur ou inférieur au plafond actuel, mais il doit être strictement supérieur au coût catalogue déjà consommé par la session, et la suppression est irréversible : un `budget` (csharp, go: `Budget`) non nul n'est accepté que sur une session qui en possède actuellement un, de sorte que vous ne pouvez pas rétablir un budget supprimé ni en ajouter un à une session créée sans budget. Consultez [Budgets de session](https://platform.claude.com/docs/fr/managed-agents/budgets#resume-a-session-at-its-budget) pour des exemples de requêtes, les comportements en cas d'erreur et ce qui est pris en compte dans le coût catalogue.

## Récupération d'une 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>

## Liste des sessions

Les résultats de `GET /v1/sessions` sont paginés. Utilisez le paramètre de requête `limit` pour contrôler la taille de la page. Chaque réponse inclut un curseur `next_page` ; transmettez-le comme paramètre `page` lors de la requête suivante pour récupérer la page suivante. `next_page` vaut `null` lorsqu'il n'y a plus de résultats.

Pour revenir à la page précédente, transmettez `prev_page` comme paramètre `page`. `prev_page` vaut `null` lorsque vous êtes sur la première page.

Un curseur `page` est opaque et encode l'`order` de la requête qui l'a produit. Le paramètre de requête `order` définit le sens de tri des résultats, `asc` ou `desc` par date de création ; la valeur par défaut est `desc` (les plus récents en premier). Réutiliser un curseur avec un `order` différent renvoie une erreur 400, tout comme modifier un filtre `created_at` de sorte qu'il exclue la position du curseur. Les autres paramètres de requête, y compris les filtres restants et `limit`, peuvent changer entre les requêtes paginées. Pour les champs de pagination communs aux points de terminaison de liste, consultez [Pagination](https://platform.claude.com/docs/fr/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"
  # Repassez next_page comme paramètre de requête page pour récupérer la page suivante,
  # ou prev_page pour revenir en arrière.
  ```

  ```bash CLI
  # --format raw renvoie une enveloppe de page avec ses curseurs prev_page et next_page ;
  # la sortie par défaut pagine automatiquement et n'émet que les sessions.
  ant beta:sessions list \
    --agent-id "$AGENT_ID" \
    --limit 1 \
    --format raw
  # Repassez next_page via --page pour récupérer la page suivante, ou prev_page pour revenir en arrière.
  ```

  ```python Python
  # Définissez `limit` à une valeur basse pour que les résultats s'étendent sur plusieurs pages.
  first_page = client.beta.sessions.list(limit=1, agent_id=agent.id)
  # `prev_page` vaut None sur la première page ; `next_page` vaut None sur la dernière.
  print(f"prev_page: {first_page.prev_page}")
  print(f"next_page: {first_page.next_page}")

  # Repassez `next_page` comme `page` pour récupérer la page suivante.
  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}")

  # Repassez `prev_page` comme `page` pour revenir à la page précédente.
  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}")
  # Pour une itération vers l'avant uniquement, l'objet page est aussi directement itérable.
  ```

  ```typescript TypeScript
  const firstPage = await client.beta.sessions.list({ limit: 1, agent_id: agent.id });
  // prev_page est null sur la première page ; next_page est défini quand d'autres sessions existent.
  console.log(`prev_page: ${firstPage.prev_page}`);
  console.log(`next_page: ${firstPage.next_page}`);

  // Passez next_page comme curseur `page` pour récupérer la deuxième page.
  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}`);
  }

  // Passez le curseur prev_page de la deuxième page pour revenir à la première page.
  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}`);
  }
  // Pour une itération en avant uniquement, l'objet page est aussi directement itérable.
  ```

  ```csharp C#
  // Le SessionListPage renvoyé par `List` expose les éléments mais pas les
  // curseurs de pagination. Pour lire `prev_page` / `next_page`, désérialisez la réponse
  // brute en SessionListPageResponse à la place.
  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"}");

  // Avancer : passez le `next_page` de la page 1 comme curseur `page`.
  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()}");
  }

  // Reculer : passez le `prev_page` de la page 2 comme même curseur `page`.
  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()}");
  }
  // Pour une itération en avant uniquement, (await client.Beta.Sessions.List(...)).Paginate() renvoie un IAsyncEnumerable qui suit automatiquement next_page.
  ```

  ```go Go
  // Page 1 : prev_page est vide car rien ne précède la première page.
  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)

  // Avancer : passez next_page comme curseur Page pour récupérer la page 2.
  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)
  }

  // Retour : le prev_page de la page 2 est le curseur de la page précédente.
  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)
  }
  // Pour une itération en avant uniquement, utilisez ListAutoPaging pour suivre automatiquement next_page.
  ```

  ```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 est un Optional vide sur la première page ; next_page pointe vers la page 2.
  IO.println("prev_page: " + firstPage.response().prevPage());
  IO.println("next_page: " + firstPage.response().nextPage());

  // Avancer en passant next_page comme curseur de page.
  var nextCursor = firstPage.response().nextPage().orElseThrow();
  var secondPage = client.beta().sessions().list(params.toBuilder().page(nextCursor).build());

  // Revenir en arrière en passant prev_page comme ce même curseur de page.
  var prevCursor = secondPage.response().prevPage().orElseThrow();
  var previousPage = client.beta().sessions().list(params.toBuilder().page(prevCursor).build());
  // De retour sur la première page, donc prev_page est à nouveau vide.
  IO.println("prev_page: " + previousPage.response().prevPage());
  // Pour une itération en avant uniquement, page.autoPager() renvoie un Iterable qui suit automatiquement next_page.
  ```

  ```php PHP
  // Page 1 : prevPage est null car rien ne précède la première page.
  $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";

  // Avancer : repasser nextPage comme curseur `page` pour récupérer la page 2.
  $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";
  }

  // Reculer : le prevPage de la page 2 est le curseur de la page précédente.
  $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";
  }
  // Pour une itération en avant uniquement, $page->pagingEachItem() produit chaque session de toutes les pages.
  ```

  ```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` vaut nil sur la première page. Le curseur de page suivante est exposé comme
  # `next_page_` (underscore final) car `next_page` seul est la méthode
  # d'assistance qui récupère l'objet de la page suivante pour vous.
  puts "prev_page: #{first_page.prev_page.inspect}"
  puts "next_page: #{first_page.next_page_.inspect}"

  # Repassez l'un ou l'autre curseur comme `page` pour parcourir la liste dans les deux sens.
  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
  # Pour une itération en avant uniquement, page.auto_paging_each suit automatiquement next_page.
  ```
</CodeGroup>

## Archivage d'une session

Archivez une session pour empêcher l'envoi de nouveaux événements tout en conservant son historique. Une session `running` ne peut pas être archivée ; pour l'archiver, envoyez un [événement `user.interrupt`](https://platform.claude.com/docs/fr/managed-agents/events-and-streaming#interrupt-the-agent) seul et attendez que la session devienne `idle`. Si une [exécution de workflow](https://platform.claude.com/docs/fr/managed-agents/workflow-runs#while-a-run-is-open) est ouverte, l'archivage peut renvoyer une erreur 400, même lorsque la session est `idle`, ou il peut réussir et mettre fin à l'exécution. Avant d'archiver, envoyez un `user.message` qui [demande à l'agent d'arrêter ses exécutions](https://platform.claude.com/docs/fr/managed-agents/workflow-runs#interrupt-a-session-with-runs-open), ou attendez que chaque exécution soit terminée. Archivez ensuite la session une fois qu'elle est `idle`.

<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>

## Suppression d'une session

Supprimez une session pour effacer définitivement son enregistrement, ses événements et le sandbox associé. Une session `running` ne peut pas être supprimée ; pour la supprimer, envoyez un [événement `user.interrupt`](https://platform.claude.com/docs/fr/managed-agents/events-and-streaming#interrupt-the-agent) seul et attendez que la session devienne `idle`. Si une [exécution de workflow](https://platform.claude.com/docs/fr/managed-agents/workflow-runs#while-a-run-is-open) est ouverte, la suppression peut renvoyer une erreur 400, même lorsque la session est `idle`, ou elle peut réussir. Après une suppression réussie, aucun événement `workflow_run` ne signale la fin des exécutions de la session. Avant de supprimer, envoyez un `user.message` qui [demande à l'agent d'arrêter ses exécutions](https://platform.claude.com/docs/fr/managed-agents/workflow-runs#interrupt-a-session-with-runs-open), ou attendez que chaque exécution soit terminée. Supprimez ensuite la session une fois qu'elle est `idle`.

Les magasins de mémoire, les coffres-forts, les skills, les environnements et les agents sont des ressources indépendantes et ne sont pas affectés par la suppression d'une session. Les fichiers que vous avez téléversés via l'API Files ne sont pas non plus affectés, mais les fichiers produits par la session elle-même lui sont rattachés et sont définitivement supprimés avec son système de fichiers. Téléchargez tout ce que vous devez conserver avant de supprimer la session. Un fichier de sortie écrit à la fin du dernier tour peut mettre quelques secondes après le passage de la session à l'état idle pour apparaître dans la [liste des fichiers de la session](https://platform.claude.com/docs/fr/managed-agents/files#listing-and-downloading-session-files) ; vérifiez donc d'abord que les fichiers attendus y figurent.

<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>