---
title: Rêves
url: https://platform.claude.com/docs/fr/managed-agents/dreams
description: Laissez Claude réfléchir aux sessions passées pour organiser la mémoire d'un agent et faire émerger de nouvelles perspectives.
---

<Tip>
  Le « dreaming » (rêve) est une fonctionnalité en aperçu de recherche. [Demandez l'accès](https://claude.com/form/claude-managed-agents) pour l'essayer.
</Tip>

Les agents écrivent dans leurs [« memory stores » (magasins de mémoire)](https://platform.claude.com/docs/fr/managed-agents/memory) au fil de leur travail, mais ces écritures sont locales et incrémentales : au fil de nombreuses sessions, un magasin de mémoire accumule des doublons, des contradictions et des entrées obsolètes.

Les **« dreams » (rêves)** permettent à Claude de faire le ménage. Un rêve lit un magasin de mémoire existant ainsi que les transcriptions de sessions passées, puis produit un nouveau magasin de mémoire réorganisé : les doublons sont fusionnés, les entrées obsolètes ou contredites sont remplacées par la valeur la plus récente, et de nouvelles perspectives émergent.

Le magasin d'entrée n'est jamais modifié, vous pouvez donc examiner la sortie et la rejeter si le résultat ne vous convient pas.

<Note>
  Les points de terminaison de rêve sont protégés par l'en-tête bêta `dreaming-2026-04-21` ; l'en-tête `managed-agents-2026-04-01` seul ne donne pas accès aux rêves. Les exemples de points de terminaison de rêve sur cette page envoient les deux en-têtes ; les appels de session et de magasin de mémoire ne nécessitent que `managed-agents-2026-04-01`. Le SDK les définit automatiquement.
</Note>

## Fonctionnement

Un **rêve** est une tâche asynchrone qui prend :

* un **magasin de mémoire** préexistant : le magasin que Claude vérifie, déduplique et réorganise, et
* 1 à 100 **sessions** : des transcriptions passées que Claude explore à la recherche de schémas et de perspectives à intégrer dans la sortie.

Le rêve produit un autre **magasin de mémoire de sortie**, distinct de l'entrée. L'ID du magasin de sortie apparaît dans le tableau `outputs` (csharp, go: `Outputs`) du rêve peu après que le rêve passe à l'état `running`, une fois que le flux de travail a cloné le magasin d'entrée ; un rêve à l'état `running` peut brièvement renvoyer un tableau `outputs` (csharp, go: `Outputs`) vide.

## Créer un rêve

<CodeGroup>
  ```bash cURL
  curl -s https://api.anthropic.com/v1/dreams \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "anthropic-beta: managed-agents-2026-04-01,dreaming-2026-04-21" \
    -H "content-type: application/json" \
    --data '{
      "inputs": [
        { "type": "memory_store", "memory_store_id": "'"$store_id"'" },
        { "type": "sessions", "session_ids": ["'"$session_a"'", "'"$session_b"'"] }
      ],
      "model": "claude-opus-5-5",
      "instructions": "Focus on coding-style preferences; ignore one-off debugging notes."
    }'
  ```

  ```bash CLI
  ant beta:dreams create <<YAML
  inputs:
    - type: memory_store
      memory_store_id: $store_id
    - type: sessions
      session_ids: [$session_a, $session_b]
  model: claude-opus-5-5
  instructions: Focus on coding-style preferences; ignore one-off debugging notes.
  YAML
  ```

  ```python Python
  dream = client.beta.dreams.create(
      inputs=[
          {"type": "memory_store", "memory_store_id": store_id},
          {"type": "sessions", "session_ids": [session_a, session_b]},
      ],
      model="claude-opus-5-5",
      instructions="Focus on coding-style preferences; ignore one-off debugging notes.",
  )
  print(dream.id)  # drm_01...
  ```

  ```typescript TypeScript
  let dream = await client.beta.dreams.create({
    inputs: [
      { type: "memory_store", memory_store_id: storeId },
      { type: "sessions", session_ids: [sessionA, sessionB] }
    ],
    model: "claude-opus-5-5",
    instructions: "Focus on coding-style preferences; ignore one-off debugging notes."
  });
  console.log(dream.id); // drm_01...
  ```

  ```csharp C#
  var dream = await client.Beta.Dreams.Create(new()
  {
      Inputs =
      [
          new BetaDreamMemoryStoreInput
          {
              Type = BetaDreamMemoryStoreInputType.MemoryStore,
              MemoryStoreID = storeID,
          },
          new BetaDreamSessionsInput
          {
              Type = BetaDreamSessionsInputType.Sessions,
              SessionIds = [sessionA, sessionB],
          },
      ],
      Model = "claude-opus-5-5",
      Instructions = "Focus on coding-style preferences; ignore one-off debugging notes.",
  });
  Console.WriteLine(dream.ID);  // drm_01...
  ```

  ```go Go
  dream, err := client.Beta.Dreams.New(ctx, anthropic.BetaDreamNewParams{
  	Inputs: []anthropic.BetaDreamInputUnionParam{
  		anthropic.BetaDreamInputParamOfMemoryStore(storeID),
  		anthropic.BetaDreamInputParamOfSessions([]string{sessionA, sessionB}),
  	},
  	Model: anthropic.BetaDreamNewParamsModelUnion{
  		OfString: anthropic.String("claude-opus-5-5"),
  	},
  	Instructions: anthropic.String("Focus on coding-style preferences; ignore one-off debugging notes."),
  })
  if err != nil {
  	panic(err)
  }
  fmt.Println(dream.ID) // drm_01...
  ```

  ```java Java
  var dream = client.beta().dreams().create(
      DreamCreateParams.builder()
          .addMemoryStoreInput(storeId)
          .addSessionsInput(List.of(sessionA, sessionB))
          .model("claude-opus-5-5")
          .instructions("Focus on coding-style preferences; ignore one-off debugging notes.")
          .build()
  );
  IO.println(dream.id());  // drm_01...
  ```

  ```php PHP
  $dream = $client->beta->dreams->create(
      inputs: [
          ['type' => 'memory_store', 'memory_store_id' => $storeId],
          ['type' => 'sessions', 'session_ids' => [$sessionA, $sessionB]],
      ],
      model: 'claude-opus-5-5',
      instructions: 'Focus on coding-style preferences; ignore one-off debugging notes.',
  );
  echo "{$dream->id}\n"; // drm_01...
  ```

  ```ruby Ruby
  dream = client.beta.dreams.create(
    inputs: [
      {type: "memory_store", memory_store_id: store_id},
      {type: "sessions", session_ids: [session_a, session_b]}
    ],
    model: "claude-opus-5-5",
    instructions: "Focus on coding-style preferences; ignore one-off debugging notes."
  )
  puts dream.id # drm_01...
  ```
</CodeGroup>

Les entrées du rêve comprennent le magasin de mémoire préexistant et un tableau de sessions. Le modèle sélectionné exécute le pipeline de rêve. Pendant l'aperçu de recherche, `claude-opus-5-5`, `claude-fable-5-1`, `claude-opus-5`, `claude-fable-5`, `claude-opus-4-8`, `claude-opus-4-7`, `claude-sonnet-5-5`, `claude-sonnet-5` et `claude-sonnet-4-6` sont pris en charge. Vous pouvez éventuellement transmettre `instructions` (csharp, go: `Instructions`) pour orienter le processus de rêve. Consultez [Orienter avec des instructions](https://platform.claude.com/docs/fr/managed-agents/dreams#steer-with-instructions).

La réponse est la ressource `dream` complète avec `status: "pending"` :

```json
{
  "type": "dream",
  "id": "drm_01AbCDefGhIjKlMnOpQrStUv",
  "status": "pending",
  "inputs": [
    { "type": "memory_store", "memory_store_id": "memstore_01Hx..." },
    { "type": "sessions", "session_ids": ["sesn_01...", "sesn_02..."] }
  ],
  "outputs": [],
  "model": { "id": "claude-opus-5-5" },
  "instructions": "Focus on coding-style preferences; ignore one-off debugging notes.",
  "session_id": null,
  "created_at": "2026-04-29T17:04:10Z",
  "ended_at": null,
  "archived_at": null,
  "usage": {
    "input_tokens": 0,
    "output_tokens": 0,
    "cache_read_input_tokens": 0,
    "cache_creation_input_tokens": 0
  },
  "error": null
}
```

<Tip>
  Si vous ne disposez que de transcriptions de sessions et d'aucun magasin existant, [créez d'abord un magasin de mémoire vide](https://platform.claude.com/docs/fr/managed-agents/memory#create-a-memory-store) et transmettez-le comme entrée `memory_store`.
</Tip>

### Orienter avec des instructions

Le champ facultatif `instructions` (csharp, go: `Instructions`) oriente ce que le pipeline de rêve synthétise. Il s'applique tout au long du pipeline : ce qu'il faut lire attentivement, ce qu'il faut fusionner ou supprimer, et comment structurer le magasin de sortie.

Utilisez `instructions` (csharp, go: `Instructions`) pour des consignes de synthèse de haut niveau, telles que des domaines d'intérêt (« concentrez-vous sur les préférences de style de code »), du contenu à conserver tel quel, ou des conventions de sortie que vous souhaitez appliquer à l'ensemble du magasin. Le pipeline est une passe de synthèse sur les entrées, et non un éditeur appliqué au texte du magasin ; les directives impératives qui ciblent des lignes précises (« remplacez la phrase X par Y », « corrigez le décompte dans la section Z ») ne produisent donc généralement aucun changement. Pour apporter des modifications ciblées à des mémoires individuelles, utilisez directement l'[API Memory Stores](https://platform.claude.com/docs/fr/managed-agents/memory#view-and-edit-memories) sur le magasin de sortie.

## Suivre la progression

Les rêves s'exécutent de manière asynchrone et prennent généralement de quelques minutes à quelques heures, selon le nombre de transcriptions en entrée. Interrogez le rêve par son ID pour vérifier son statut :

<CodeGroup>
  ```bash cURL
  curl -s "https://api.anthropic.com/v1/dreams/$dream_id" \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "anthropic-beta: managed-agents-2026-04-01,dreaming-2026-04-21"
  ```

  ```bash CLI
  ant beta:dreams retrieve --dream-id "$dream_id"
  ```

  ```python Python
  while dream.status in ("pending", "running"):
      time.sleep(10)
      dream = client.beta.dreams.retrieve(dream.id)
      print(f"status={dream.status} input_tokens={dream.usage.input_tokens}")
  ```

  ```typescript TypeScript
  while (dream.status === "pending" || dream.status === "running") {
    await sleep(10_000);
    dream = await client.beta.dreams.retrieve(dream.id);
    console.log(`status=${dream.status} input_tokens=${dream.usage.input_tokens}`);
  }
  ```

  ```csharp C#
  while (dream.Status.Value() is BetaDreamStatus.Pending or BetaDreamStatus.Running)
  {
      await Task.Delay(TimeSpan.FromSeconds(10));
      dream = await client.Beta.Dreams.Retrieve(dream.ID);
      Console.WriteLine($"status={dream.Status.Raw()} input_tokens={dream.Usage.InputTokens}");
  }
  ```

  ```go Go
  for dream.Status == anthropic.BetaDreamStatusPending || dream.Status == anthropic.BetaDreamStatusRunning {
  	time.Sleep(10 * time.Second)
  	dream, err = client.Beta.Dreams.Get(ctx, dream.ID, anthropic.BetaDreamGetParams{})
  	if err != nil {
  		panic(err)
  	}
  	fmt.Printf("status=%s input_tokens=%d\n", dream.Status, dream.Usage.InputTokens)
  }
  ```

  ```java Java
  while (dream.status().equals(BetaDreamStatus.PENDING)
          || dream.status().equals(BetaDreamStatus.RUNNING)) {
      Thread.sleep(10_000);
      dream = client.beta().dreams().retrieve(dream.id());
      IO.println("status=" + dream.status() + " input_tokens=" + dream.usage().inputTokens());
  }
  ```

  ```php PHP
  while (in_array($dream->status, [BetaDreamStatus::PENDING->value, BetaDreamStatus::RUNNING->value], true)) {
      sleep(10);
      $dream = $client->beta->dreams->retrieve($dream->id);
      echo "status={$dream->status} input_tokens={$dream->usage->inputTokens}\n";
  }
  ```

  ```ruby Ruby
  while %i[pending running].include?(dream.status)
    sleep 10
    dream = client.beta.dreams.retrieve(dream.id)
    puts "status=#{dream.status} input_tokens=#{dream.usage.input_tokens}"
  end
  ```
</CodeGroup>

### Cycle de vie

| `status` (csharp, go: `Status`) | Signification                                                                                                                                  |
| ------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------- |
| `pending`                       | Rêve créé avec succès et mis en file d'attente.                                                                                                |
| `running`                       | Le pipeline est en cours de traitement. `usage` (csharp, go: `Usage`) est mis à jour au fur et à mesure de l'avancement.                       |
| `completed`                     | Terminé avec succès. La valeur `outputs` (csharp, go: `Outputs`) est le nouveau magasin de mémoire.                                            |
| `failed`                        | L'exécution du rêve s'est terminée par une erreur. Le magasin de mémoire de sortie est laissé tel quel, avec ce qui a été écrit avant l'échec. |
| `canceled`                      | Exécution du rêve annulée. Le magasin de mémoire de sortie est laissé tel quel.                                                                |

### Observer l'exécution du pipeline

Une fois qu'un rêve est à l'état `running`, son champ `session_id` (java: `sessionId`; php: `sessionID`; csharp, go: `SessionID`) pointe vers la [session](https://platform.claude.com/docs/fr/managed-agents/sessions) sous-jacente qui exécute le pipeline. Vous pouvez diffuser en streaming les [événements](https://platform.claude.com/docs/fr/managed-agents/events-and-streaming) de cette session pour observer en temps réel ce que le rêve lit et écrit. La session est archivée (et non supprimée) lorsque le rêve atteint un état terminal, de sorte que la transcription reste disponible par la suite.

## Utiliser la sortie

Lorsque `status` (csharp, go: `Status`) atteint `completed`, l'entrée `memory_store` dans `outputs` (csharp, go: `Outputs`) référence un magasin entièrement rempli. Il s'agit d'un magasin de mémoire ordinaire dans votre espace de travail. Examinez-le avec l'[API Memory Stores](https://platform.claude.com/docs/fr/managed-agents/memory#view-and-edit-memories) ou dans la Console, puis au choix :

* **Exploitez-le :** attachez-le aux sessions futures en tant que ressource `memory_store` à la place (ou en complément) du magasin de mémoire d'entrée, ou
* **Rejetez-le :** [supprimez le magasin de mémoire](https://platform.claude.com/docs/fr/api/beta/memory_stores/delete) ou [archivez le magasin de mémoire](https://platform.claude.com/docs/fr/api/beta/memory_stores/archive).

<CodeGroup>
  ```bash cURL
  # $output_store_id is the memory_store_id of the completed dream's memory_store output
  curl -s 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" \
    --data '{
      "agent": "'"$agent_id"'",
      "environment_id": "'"$environment_id"'",
      "resources": [
        { "type": "memory_store", "memory_store_id": "'"$output_store_id"'" }
      ]
    }'
  ```

  ```bash CLI
  # $output_store_id is the memory_store_id of the completed dream's memory_store output
  ant beta:sessions create <<YAML
  agent: $agent_id
  environment_id: $environment_id
  resources:
    - type: memory_store
      memory_store_id: $output_store_id
  YAML
  ```

  ```python Python
  # Une fois le rêve terminé, la sortie contient le magasin de mémoire reconstruit
  output_store_id = next(
      output.memory_store_id for output in dream.outputs if output.type == "memory_store"
  )

  session = client.beta.sessions.create(
      agent=agent_id,
      environment_id=environment_id,
      resources=[
          {"type": "memory_store", "memory_store_id": output_store_id},
      ],
  )
  ```

  ```typescript TypeScript
  // Une fois le dream terminé, la sortie contient le magasin de mémoire reconstruit
  const output = dream.outputs.find((entry) => entry.type === "memory_store");
  const outputStoreId = output!.memory_store_id;

  await client.beta.sessions.create({
    agent: agentId,
    environment_id: environmentId,
    resources: [{ type: "memory_store", memory_store_id: outputStoreId }]
  });
  ```

  ```csharp C#
  var output = dream.Outputs.FirstOrDefault(entry => entry.Type == "memory_store");
  if (output is { MemoryStoreID: var outputStoreID })
  {
      await client.Beta.Sessions.Create(new()
      {
          Agent = agentID,
          EnvironmentID = environmentID,
          Resources =
          [
              new BetaManagedAgentsMemoryStoreResourceParam
              {
                  Type = BetaManagedAgentsMemoryStoreResourceParamType.MemoryStore,
                  MemoryStoreID = outputStoreID,
              },
          ],
      });
  }
  ```

  ```go Go
  for _, output := range dream.Outputs {
  	if output.Type != "memory_store" {
  		continue
  	}
  	outputStoreID := output.MemoryStoreID

  	session, err := client.Beta.Sessions.New(ctx, anthropic.BetaSessionNewParams{
  		Agent: anthropic.BetaSessionNewParamsAgentUnion{
  			OfString: anthropic.String(agentID),
  		},
  		EnvironmentID: environmentID,
  		Resources: []anthropic.BetaSessionNewParamsResourceUnion{{
  			OfMemoryStore: &anthropic.BetaManagedAgentsMemoryStoreResourceParam{
  				Type:          anthropic.BetaManagedAgentsMemoryStoreResourceParamTypeMemoryStore,
  				MemoryStoreID: outputStoreID,
  			},
  		}},
  	})
  	if err != nil {
  		panic(err)
  	}
  	fmt.Println(session.ID)
  	break
  }
  ```

  ```java Java
  var output = dream.outputs().stream()
      .filter(entry -> entry.type().equals(BetaDreamOutput.Type.MEMORY_STORE))
      .findFirst();
  if (output.isPresent()) {
      var outputStoreId = output.get().memoryStoreId();

      var session = client.beta().sessions().create(
          SessionCreateParams.builder()
              .agent(agentId)
              .environmentId(environmentId)
              .addMemoryStoreResource(outputStoreId)
              .build()
      );
  }
  ```

  ```php PHP
  $matches = array_filter($dream->outputs, fn($output) => $output->type === 'memory_store');
  $output = $matches ? reset($matches) : null;
  if ($output !== null) {
      $session = $client->beta->sessions->create(
          agent: $agentId,
          environmentID: $environmentId,
          resources: [
              ['type' => 'memory_store', 'memory_store_id' => $output->memoryStoreID],
          ],
      );
  }
  ```

  ```ruby Ruby
  output = dream.outputs.find { it.type == :memory_store }
  if output
    client.beta.sessions.create(
      agent: agent_id,
      environment_id: environment_id,
      resources: [
        {type: "memory_store", memory_store_id: output.memory_store_id}
      ]
    )
  end
  ```
</CodeGroup>

Le rêve lui-même ne supprime ni ne modifie jamais ses entrées. En cas d'état `failed` ou `canceled`, le magasin de sortie persiste avec un contenu partiel afin que vous puissiez inspecter ce qui a été produit avant l'arrêt ; nettoyez-le via l'API Memory Stores si vous n'en avez pas besoin.

<Warning>
  Tant qu'un rêve est à l'état `pending` ou `running`, la protection 400 s'applique à l'archivage du rêve lui-même, et non à ses magasins. Archiver ou supprimer un magasin de mémoire d'*entrée* en cours d'exécution (ou supprimer une session d'entrée) fera échouer le rêve avec `input_memory_store_unavailable` ou `input_session_unavailable`.
</Warning>

## Annuler un rêve

L'annulation fait passer immédiatement un rêve `pending` ou `running` à l'état `canceled`. Annuler un rêve déjà `canceled` est une opération idempotente sans effet ; annuler un rêve `completed` ou `failed` renvoie 400.

<Note>
  Après l'annulation, les champs `usage` (csharp, go: `Usage`) du rêve peuvent continuer à être mis à jour pendant quelques secondes, le temps que le travail en cours se termine. Interrogez le rêve jusqu'à ce que `usage` (csharp, go: `Usage`) se stabilise si vous avez besoin du décompte final.
</Note>

<CodeGroup>
  ```bash cURL
  curl -s -X POST "https://api.anthropic.com/v1/dreams/$dream_id/cancel" \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "anthropic-beta: managed-agents-2026-04-01,dreaming-2026-04-21"
  ```

  ```bash CLI
  ant beta:dreams cancel --dream-id "$dream_id"
  ```

  ```python Python
  client.beta.dreams.cancel(dream.id)
  ```

  ```typescript TypeScript
  await client.beta.dreams.cancel(dream.id);
  ```

  ```csharp C#
  await client.Beta.Dreams.Cancel(dream.ID);
  ```

  ```go Go
  dream, err = client.Beta.Dreams.Cancel(ctx, dream.ID, anthropic.BetaDreamCancelParams{})
  if err != nil {
  	panic(err)
  }
  ```

  ```java Java
  client.beta().dreams().cancel(dream.id());
  ```

  ```php PHP
  $client->beta->dreams->cancel($dream->id);
  ```

  ```ruby Ruby
  client.beta.dreams.cancel(dream.id)
  ```
</CodeGroup>

## Archiver un rêve

L'archivage définit `archived_at` (java, php: `archivedAt`; csharp, go: `ArchivedAt`) sur un rêve ayant atteint un état terminal (`completed`, `failed` ou `canceled`) ; `status` (csharp, go: `Status`) reste inchangé. Les rêves archivés sont exclus des réponses de liste par défaut, mais restent lisibles par leur ID. Archiver un rêve déjà archivé est une opération idempotente sans effet. Archiver un rêve `pending` ou `running` renvoie 400 ; annulez-le d'abord. Il n'est pas possible de désarchiver.

<CodeGroup>
  ```bash cURL
  curl -s -X POST "https://api.anthropic.com/v1/dreams/$dream_id/archive" \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "anthropic-beta: managed-agents-2026-04-01,dreaming-2026-04-21"
  ```

  ```bash CLI
  ant beta:dreams archive --dream-id "$dream_id"
  ```

  ```python Python
  client.beta.dreams.archive(dream.id)
  ```

  ```typescript TypeScript
  await client.beta.dreams.archive(dream.id);
  ```

  ```csharp C#
  await client.Beta.Dreams.Archive(dream.ID);
  ```

  ```go Go
  dream, err = client.Beta.Dreams.Archive(ctx, dream.ID, anthropic.BetaDreamArchiveParams{})
  if err != nil {
  	panic(err)
  }
  ```

  ```java Java
  client.beta().dreams().archive(dream.id());
  ```

  ```php PHP
  $client->beta->dreams->archive($dream->id);
  ```

  ```ruby Ruby
  client.beta.dreams.archive(dream.id)
  ```
</CodeGroup>

L'archivage d'un rêve ne touche pas à son magasin de mémoire de sortie ; gérez celui-ci séparément via l'[API Memory Stores](https://platform.claude.com/docs/fr/managed-agents/memory#view-and-edit-memories).

## Lister les rêves

Renvoie tous les rêves non archivés de l'espace de travail, du plus récent au plus ancien. Utilisez `limit` (csharp, go: `Limit`) (20 par défaut, 100 maximum) et le curseur `page` (csharp, go: `Page`) pour paginer. Définissez `include_archived` (java, php: `includeArchived`; csharp, go: `IncludeArchived`) sur `true` pour inclure les rêves archivés.

<CodeGroup>
  ```bash cURL
  curl -s "https://api.anthropic.com/v1/dreams?limit=20" \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "anthropic-beta: managed-agents-2026-04-01,dreaming-2026-04-21"
  ```

  ```bash CLI
  ant beta:dreams list --limit 20
  ```

  ```python Python
  for listed_dream in client.beta.dreams.list(limit=20):
      print(listed_dream.id, listed_dream.status)
  ```

  ```typescript TypeScript
  for await (const listedDream of client.beta.dreams.list({ limit: 20 })) {
    console.log(listedDream.id, listedDream.status);
  }
  ```

  ```csharp C#
  var page = await client.Beta.Dreams.List(new() { Limit = 20 });
  await foreach (var listed in page.Paginate())
  {
      Console.WriteLine($"{listed.ID} {listed.Status.Raw()}");
  }
  ```

  ```go Go
  dreams := client.Beta.Dreams.ListAutoPaging(ctx, anthropic.BetaDreamListParams{
  	Limit: anthropic.Int(20),
  })
  for dreams.Next() {
  	listed := dreams.Current()
  	fmt.Println(listed.ID, listed.Status)
  }
  if err := dreams.Err(); err != nil {
  	panic(err)
  }
  ```

  ```java Java
  for (var listedDream : client.beta().dreams().list(
      DreamListParams.builder().limit(20).build()
  ).autoPager()) {
      IO.println(listedDream.id() + " " + listedDream.status());
  }
  ```

  ```php PHP
  foreach ($client->beta->dreams->list(limit: 20)->pagingEachItem() as $dream) {
      echo "{$dream->id} {$dream->status}\n";
  }
  ```

  ```ruby Ruby
  client.beta.dreams.list(limit: 20).auto_paging_each do
    puts "#{it.id} #{it.status}"
  end
  ```
</CodeGroup>

## Erreurs

Voici une liste non exhaustive des erreurs de rêve possibles.

| `error.type`                      | Quand                                                                                                                         |
| --------------------------------- | ----------------------------------------------------------------------------------------------------------------------------- |
| `timeout`                         | Le pipeline a dépassé son budget de temps d'exécution.                                                                        |
| `internal_error`                  | Échec du pipeline non classifié.                                                                                              |
| `memory_store_org_limit_exceeded` | Votre organisation a atteint son plafond de magasins de mémoire pendant que le pipeline provisionnait le stockage de travail. |
| `input_memory_store_too_large`    | Le magasin de mémoire d'entrée dépasse la limite de taille du pipeline.                                                       |
| `input_memory_store_unavailable`  | Le magasin de mémoire d'entrée a été archivé ou supprimé après la création du rêve.                                           |
| `input_session_unavailable`       | Une session d'entrée a été supprimée après la création du rêve.                                                               |

## Facturation

Les rêves sont facturés aux tarifs standard par token de l'API pour le modèle que vous sélectionnez ; `usage` (csharp, go: `Usage`) sur la ressource indique les totaux exacts. Le coût évolue de manière à peu près linéaire avec le nombre et la longueur des sessions d'entrée. Commencez par un petit lot de sessions et augmentez l'échelle une fois satisfait de la qualité de l'organisation.

## Limites

| Limite                                                  | Valeur                                                                                                                                                                      |
| ------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Sessions par rêve                                       | 100                                                                                                                                                                         |
| Longueur de `instructions` (csharp, go: `Instructions`) | 4 096 caractères                                                                                                                                                            |
| Modèles pris en charge                                  | `claude-opus-5-5`, `claude-fable-5-1`, `claude-opus-5`, `claude-fable-5`, `claude-opus-4-8`, `claude-opus-4-7`, `claude-sonnet-5-5`, `claude-sonnet-5`, `claude-sonnet-4-6` |

Les limites de débit par défaut s'appliquent à la création de rêves tant que cette fonctionnalité est en aperçu de recherche. [Contactez l'assistance](https://support.claude.com) si vous avez besoin de limites plus élevées.