---
title: Effort par message
url: https://platform.claude.com/docs/fr/build-with-claude/effort-per-message
description: Utilisez un message système pour modifier le niveau d'effort en cours de conversation tout en conservant le cache des prompts.
featureMetadata:
  status: beta
  betaHeader: mid-conversation-output-config-2026-07-01
  supportedModels:
    - claude-fable-5-2
    - claude-mythos-5-2
    - claude-fable-5-1
    - claude-mythos-5-1
    - claude-opus-5-5
    - claude-opus-5
    - claude-sonnet-5-5
    - claude-haiku-5-5
  supportedPlatforms:
    Claude API: beta
    Amazon Bedrock: beta
    Amazon Bedrock (bedrock-runtime):
      availability: beta
      note: Envoyez la valeur bêta dans le tableau `anthropic_beta` du corps de la requête.
    Claude Platform on AWS: beta
    Claude Models on Google Cloud (Anthropic managed): beta
    Claude Models on Google Cloud (Google managed): beta
    Microsoft Foundry: beta
---

Une modification de l’effort par message définit un nouveau niveau d’effort pour les tours ultérieurs d’une conversation sans modifier la valeur de premier niveau de la requête, de sorte que le préfixe mis en cache correspond toujours.

## Modifier le niveau d’effort

Pour modifier le niveau en cours de conversation :

1. Ajoutez un message `role: "system"` à `messages`, avec un `content` vide et le nouveau niveau d’[effort](https://platform.claude.com/docs/fr/build-with-claude/effort) dans `output_config.effort`.
2. Envoyez l’[en-tête bêta](https://platform.claude.com/docs/fr/api/beta-headers) `mid-conversation-output-config-2026-07-01`.
3. Laissez la valeur de premier niveau inchangée.

L’exemple suivant conserve la valeur de premier niveau à `high` et passe à `low` pour une question de suivi de routine :

<CodeGroup>
  ```bash cURL
  # Message système d'effort seul : le nouveau niveau prend effet au prochain tour de l'utilisateur.
  curl https://api.anthropic.com/v1/messages \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2026-10-21" \
    -H "anthropic-beta: mid-conversation-output-config-2026-07-01" \
    -H "content-type: application/json" \
    -d '{
      "model": "claude-fable-5-1",
      "max_tokens": 4096,
      "output_config": {"effort": "high"},
      "messages": [
        {"role": "user", "content": "Plan a migration from SQLite to PostgreSQL in three short steps."},
        {"role": "assistant", "content": "1. Export the SQLite data. 2. Create the PostgreSQL schema. 3. Import the data and verify row counts."},
        {"role": "system", "content": [], "output_config": {"effort": "low"}},
        {"role": "user", "content": "Summarize the plan in one sentence."}
      ]
    }'
  ```

  ```bash CLI
  ant beta:messages create \
    --beta mid-conversation-output-config-2026-07-01 <<'YAML'
  model: claude-fable-5-1
  max_tokens: 4096
  output_config:
    effort: high
  messages:
    - role: user
      content: Plan a migration from SQLite to PostgreSQL in three short steps.
    - role: assistant
      content: "1. Export the SQLite data. 2. Create the PostgreSQL schema. 3. Import the data and verify row counts."
    # Message système d'effort uniquement : le nouveau niveau s'applique à partir du prochain tour utilisateur.
    - role: system
      content: []
      output_config:
        effort: low
    - role: user
      content: Summarize the plan in one sentence.
  YAML
  ```

  ```python Python
  client = anthropic.Anthropic()

  response = client.beta.messages.create(
      model="claude-fable-5-1",
      max_tokens=4096,
      output_config={"effort": "high"},
      messages=[
          {
              "role": "user",
              "content": "Plan a migration from SQLite to PostgreSQL in three short steps.",
          },
          {
              "role": "assistant",
              "content": "1. Export the SQLite data. 2. Create the PostgreSQL schema. 3. Import the data and verify row counts.",
          },
          # Message système portant uniquement sur l'effort : le nouveau niveau s'applique dès le prochain tour de l'utilisateur.
          {"role": "system", "content": [], "output_config": {"effort": "low"}},
          {"role": "user", "content": "Summarize the plan in one sentence."},
      ],
      betas=["mid-conversation-output-config-2026-07-01"],
  )

  for block in response.content:
      if block.type == "text":
          print(block.text)
  ```

  ```typescript TypeScript
  const client = new Anthropic();

  const response = await client.beta.messages.create({
    model: "claude-fable-5-1",
    max_tokens: 4096,
    output_config: { effort: "high" },
    messages: [
      {
        role: "user",
        content: "Plan a migration from SQLite to PostgreSQL in three short steps."
      },
      {
        role: "assistant",
        content:
          "1. Export the SQLite data. 2. Create the PostgreSQL schema. 3. Import the data and verify row counts."
      },
      // Message système portant uniquement sur l'effort : le nouveau niveau s'applique à partir du prochain tour utilisateur.
      { role: "system", content: [], output_config: { effort: "low" } },
      { role: "user", content: "Summarize the plan in one sentence." }
    ],
    betas: ["mid-conversation-output-config-2026-07-01"]
  });

  for (const block of response.content) {
    if (block.type === "text") {
      console.log(block.text);
    }
  }
  ```

  ```csharp C#
  using Anthropic.Models.Beta;
  using Anthropic.Models.Beta.Messages;
  using Model = Anthropic.Models.Messages.Model;

  AnthropicClient client = new();

  var response = await client.Beta.Messages.Create(new MessageCreateParams
  {
      Model = Model.ClaudeFable5_1,
      MaxTokens = 4096,
      OutputConfig = new() { Effort = Effort.High },
      Messages =
      [
          new BetaUserMessageParam { Content = "Plan a migration from SQLite to PostgreSQL in three short steps." },
          new BetaAssistantMessageParam { Content = "1. Export the SQLite data. 2. Create the PostgreSQL schema. 3. Import the data and verify row counts." },
          // Message système limité à l'effort : le nouveau niveau s'applique à partir du prochain tour de l'utilisateur.
          new BetaSystemMessageParam
          {
              Content = new([]),
              OutputConfig = new() { Effort = BetaSystemMessageOutputConfigEffort.Low },
          },
          new BetaUserMessageParam { Content = "Summarize the plan in one sentence." },
      ],
      Betas = [AnthropicBeta.MidConversationOutputConfig2026_07_01],
  });

  foreach (var block in response.Content)
  {
      if (block.TryPickText(out var textBlock))
      {
          Console.WriteLine(textBlock.Text);
      }
  }
  ```

  ```go Go
  client := anthropic.NewClient()

  response, err := client.Beta.Messages.New(context.Background(), anthropic.BetaMessageNewParams{
  	Model:     anthropic.ModelClaudeFable5_1,
  	MaxTokens: 4096,
  	OutputConfig: anthropic.BetaOutputConfigParam{
  		Effort: anthropic.BetaOutputConfigEffortHigh,
  	},
  	Messages: []anthropic.BetaMessageParam{
  		anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Plan a migration from SQLite to PostgreSQL in three short steps.")),
  		{OfAssistant: &anthropic.BetaAssistantMessageParam{
  			Content: []anthropic.BetaContentBlockParamUnion{anthropic.NewBetaTextBlock("1. Export the SQLite data. 2. Create the PostgreSQL schema. 3. Import the data and verify row counts.")},
  		}},
  		// Message système d'effort uniquement : le nouveau niveau s'applique à partir du prochain tour utilisateur.
  		anthropic.NewBetaSystemMessage(anthropic.BetaSystemMessageOutputConfigParam{
  			Effort: anthropic.BetaSystemMessageOutputConfigEffortLow,
  		}),
  		anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Summarize the plan in one sentence.")),
  	},
  	Betas: []anthropic.AnthropicBeta{anthropic.AnthropicBetaMidConversationOutputConfig2026_07_01},
  })
  if err != nil {
  	log.Fatal(err)
  }

  for _, block := range response.Content {
  	if textBlock, ok := block.AsAny().(anthropic.BetaTextBlock); ok {
  		fmt.Println(textBlock.Text)
  	}
  }
  ```

  ```java Java
  import com.anthropic.models.beta.AnthropicBeta;
  import com.anthropic.models.beta.messages.BetaMessage;
  import com.anthropic.models.beta.messages.BetaOutputConfig;
  import com.anthropic.models.beta.messages.BetaSystemMessageOutputConfig;
  import com.anthropic.models.beta.messages.BetaSystemMessageParam;
  import com.anthropic.models.beta.messages.MessageCreateParams;
  import com.anthropic.models.messages.Model;

  void main() {
      AnthropicClient client = AnthropicOkHttpClient.fromEnv();

      MessageCreateParams params = MessageCreateParams.builder()
          .model(Model.CLAUDE_FABLE_5_1)
          .maxTokens(4096L)
          .addBeta(AnthropicBeta.MID_CONVERSATION_OUTPUT_CONFIG_2026_07_01)
          .outputConfig(BetaOutputConfig.builder()
              .effort(BetaOutputConfig.Effort.HIGH)
              .build())
          .addUserMessage("Plan a migration from SQLite to PostgreSQL in three short steps.")
          .addAssistantMessage("1. Export the SQLite data. 2. Create the PostgreSQL schema. 3. Import the data and verify row counts.")
          // Message système portant uniquement sur l'effort : le nouveau niveau s'applique à partir du prochain tour utilisateur.
          .addMessage(BetaSystemMessageParam.builder()
              .contentOfBlocks(List.of())
              .outputConfig(BetaSystemMessageOutputConfig.builder()
                  .effort(BetaSystemMessageOutputConfig.Effort.LOW)
                  .build())
              .build())
          .addUserMessage("Summarize the plan in one sentence.")
          .build();

      BetaMessage response = client.beta().messages().create(params);
      response.content().stream()
          .flatMap(block -> block.text().stream())
          .forEach(textBlock -> IO.println(textBlock.text()));
  }
  ```

  ```php PHP
  use Anthropic\Beta\AnthropicBeta;
  use Anthropic\Beta\Messages\BetaMessageParam;
  use Anthropic\Beta\Messages\BetaOutputConfig;
  use Anthropic\Beta\Messages\BetaSystemMessageOutputConfig;
  use Anthropic\Beta\Messages\BetaTextBlock;
  use Anthropic\Client;
  use Anthropic\Messages\Model;

  $client = new Client();

  $response = $client->beta->messages->create(
      model: Model::CLAUDE_FABLE_5_1,
      maxTokens: 4096,
      outputConfig: BetaOutputConfig::with(effort: 'high'),
      messages: [
          BetaMessageParam::with(role: 'user', content: 'Plan a migration from SQLite to PostgreSQL in three short steps.'),
          BetaMessageParam::with(role: 'assistant', content: '1. Export the SQLite data. 2. Create the PostgreSQL schema. 3. Import the data and verify row counts.'),
          // Message système d'effort uniquement : le nouveau niveau s'applique à partir du prochain tour de l'utilisateur.
          BetaMessageParam::with(
              role: 'system',
              content: [],
              outputConfig: BetaSystemMessageOutputConfig::with(effort: 'low'),
          ),
          BetaMessageParam::with(role: 'user', content: 'Summarize the plan in one sentence.'),
      ],
      betas: [AnthropicBeta::MID_CONVERSATION_OUTPUT_CONFIG_2026_07_01],
  );

  foreach ($response->content as $block) {
      if ($block instanceof BetaTextBlock) {
          echo $block->text, PHP_EOL;
      }
  }
  ```

  ```ruby Ruby
  client = Anthropic::Client.new

  response = client.beta.messages.create(
    model: Anthropic::Model::CLAUDE_FABLE_5_1,
    max_tokens: 4096,
    output_config: {effort: :high},
    messages: [
      {role: "user", content: "Plan a migration from SQLite to PostgreSQL in three short steps."},
      {role: "assistant", content: "1. Export the SQLite data. 2. Create the PostgreSQL schema. 3. Import the data and verify row counts."},
      # Message système portant uniquement sur l'effort : le nouveau niveau s'applique dès le prochain tour utilisateur.
      {role: "system", content: [], output_config: {effort: :low}},
      {role: "user", content: "Summarize the plan in one sentence."}
    ],
    betas: [Anthropic::AnthropicBeta::MID_CONVERSATION_OUTPUT_CONFIG_2026_07_01]
  )

  response.content.each do |block|
    case block
    when Anthropic::Beta::BetaTextBlock
      puts block.text
    end
  end
  ```
</CodeGroup>

La position du message détermine le moment où le nouveau niveau entre en vigueur :

* Directement après un tour `user` contenant une nouvelle entrée : la réponse de Claude à ce tour utilise le nouveau niveau.
* À toute autre position, par exemple entre un tour `assistant` et le tour `user` suivant comme dans l’exemple précédent : le nouveau niveau commence au prochain tour `user` contenant une nouvelle entrée.

Un tour `user` ne contenant que des blocs `tool_result` ne compte pas comme une nouvelle entrée.

Le nouveau niveau reste en vigueur jusqu’à ce qu’un message ultérieur le modifie.

Placez le message après tout ce que vous avez déjà envoyé, et conservez-le à sa place lors des requêtes ultérieures. Ne l’insérez pas avant des tours que vous avez déjà envoyés, et ne le déplacez ni ne le supprimez par la suite. Sur les modèles avec « [preserved thinking](https://platform.claude.com/docs/fr/build-with-claude/preserved-thinking) » (réflexion préservée), chacune de ces modifications invalide les blocs de réflexion dans les tours `assistant` situés après le message. [Ce que fait l’API d’un bloc invalide](https://platform.claude.com/docs/fr/build-with-claude/preserved-thinking#mismatch-behavior) indique ce qui se passe ensuite.

S’il se trouve à côté d’un message `system` qui a du contenu, les deux messages doivent suivre les [règles de placement des messages système en cours de conversation](https://platform.claude.com/docs/fr/build-with-claude/mid-conversation-system-messages#limitations).

Avec l’API InvokeModel d’Amazon Bedrock, envoyez la valeur bêta dans le tableau `anthropic_beta` du corps de la requête au lieu de l’en-tête. Pour connaître les modèles qui prennent en charge l’effort par message sur cette plateforme, consultez [Messages système en cours de conversation sur Bedrock](https://platform.claude.com/docs/fr/build-with-claude/claude-on-amazon-bedrock-legacy#mid-conversation-system-messages-on-bedrock).

## Erreurs

* Sans l’en-tête bêta, un `output_config` par message renvoie une erreur 400 : `messages.N.output_config: Extra inputs are not permitted`, où `N` est l’index du message `system` dans `messages`.
* Avec l’en-tête bêta, les modèles sans effort par message, tels que Claude Fable 5, renvoient une erreur 400 : `output_config.effort requires a model that supports per-turn effort; this model does not`. Sur Amazon Bedrock, ces modèles et Claude Opus 5 renvoient plutôt `Extra inputs are not permitted`.
* Sur Claude Sonnet 5.5 avec `thinking: {"type": "between_tools"}`, et sur Claude Haiku 5.5 avec `thinking: {"type": "disabled"}`, vous ne pouvez pas modifier le niveau d’effort en cours de conversation. Dans ces cas, un `output_config.effort` par message avec un nouveau niveau renvoie une erreur 400. Pour faire varier l’effort à chaque tour, utilisez la réflexion adaptative.

## Effort par message ou de premier niveau

Privilégiez l’effort par message plutôt que de [modifier la valeur de premier niveau](https://platform.claude.com/docs/fr/build-with-claude/effort#top-level-effort-on-the-next-request) entre les requêtes. Une modification par message laisse inchangé tout ce qui la précède, de sorte que le préfixe mis en cache correspond toujours. Une modification de premier niveau redémarre le cache. Sur Claude Fable 5.1, une modification de premier niveau oriente également le modèle de manière moins fiable. Les réponses précédentes du modèle ont été rédigées au niveau précédent, et le modèle tend à rester cohérent avec elles.

## Disponibilité

Effort par message est en bêta sur certains modèles.

### Prise en charge de l’API

#### [Messages API](https://platform.claude.com/docs/fr/build-with-claude/working-with-messages)

* Disponibilité : Disponible

| Statut           | Plateformes cloud                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | Modèles                                                                                                                                                                                                                                                                                                                                    |
| ---------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| Bêta             | Claude API, [Amazon Bedrock](https://platform.claude.com/docs/fr/build-with-claude/claude-in-amazon-bedrock), [Claude Platform on AWS](https://platform.claude.com/docs/fr/build-with-claude/claude-platform-on-aws), [Claude Models on Google Cloud (Anthropic managed)](https://platform.claude.com/docs/fr/build-with-claude/claude-models-on-google-cloud/anthropic-managed), [Claude Models on Google Cloud (Google managed)](https://platform.claude.com/docs/fr/build-with-claude/claude-models-on-google-cloud/google-managed), [Microsoft Foundry](https://platform.claude.com/docs/fr/build-with-claude/claude-in-microsoft-foundry) | [Claude Fable 5.1](https://platform.claude.com/docs/fr/models/fable-5-1/overview), [Claude Opus 5.5](https://platform.claude.com/docs/fr/models/opus-5-5/overview)                                                                                                                                                                         |
| Bêta<sup>1</sup> | [Amazon Bedrock (bedrock-runtime)](https://platform.claude.com/docs/fr/build-with-claude/claude-on-amazon-bedrock-legacy)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | [Claude Fable 5.2](https://platform.claude.com/docs/fr/models/fable-5-2/overview), [Claude Mythos 5.2](https://platform.claude.com/docs/fr/models/mythos-5-2/overview), [Claude Fable 5.1](https://platform.claude.com/docs/fr/models/fable-5-1/overview), [Claude Opus 5.5](https://platform.claude.com/docs/fr/models/opus-5-5/overview) |
| Bêta             | Claude API, [Claude Platform on AWS](https://platform.claude.com/docs/fr/build-with-claude/claude-platform-on-aws), [Claude Models on Google Cloud (Anthropic managed)](https://platform.claude.com/docs/fr/build-with-claude/claude-models-on-google-cloud/anthropic-managed), [Claude Models on Google Cloud (Google managed)](https://platform.claude.com/docs/fr/build-with-claude/claude-models-on-google-cloud/google-managed), [Microsoft Foundry](https://platform.claude.com/docs/fr/build-with-claude/claude-in-microsoft-foundry)                                                                                                   | [Claude Fable 5.2](https://platform.claude.com/docs/fr/models/fable-5-2/overview), [Claude Opus 5](https://platform.claude.com/docs/fr/models/opus-5/overview), [Claude Sonnet 5.5](https://platform.claude.com/docs/fr/models/sonnet-5-5/overview), [Claude Haiku 5.5](https://platform.claude.com/docs/fr/models/haiku-5-5/overview)     |
| Bêta             | Claude API, [Amazon Bedrock](https://platform.claude.com/docs/fr/build-with-claude/claude-in-amazon-bedrock), [Claude Models on Google Cloud (Google managed)](https://platform.claude.com/docs/fr/build-with-claude/claude-models-on-google-cloud/google-managed), [Microsoft Foundry (hosted on Anthropic)](https://platform.claude.com/docs/fr/build-with-claude/claude-in-microsoft-foundry)                                                                                                                                                                                                                                               | [Claude Mythos 5.1](https://platform.claude.com/docs/fr/models/mythos-5-1/overview)                                                                                                                                                                                                                                                        |
| Bêta             | Claude API, [Claude Models on Google Cloud (Anthropic managed)](https://platform.claude.com/docs/fr/build-with-claude/claude-models-on-google-cloud/anthropic-managed), [Claude Models on Google Cloud (Google managed)](https://platform.claude.com/docs/fr/build-with-claude/claude-models-on-google-cloud/google-managed), [Microsoft Foundry (hosted on Anthropic)](https://platform.claude.com/docs/fr/build-with-claude/claude-in-microsoft-foundry)                                                                                                                                                                                     | [Claude Mythos 5.2](https://platform.claude.com/docs/fr/models/mythos-5-2/overview)                                                                                                                                                                                                                                                        |

1. Envoyez la valeur bêta dans le tableau `anthropic_beta` du corps de la requête.

#### [Managed Agents](https://platform.claude.com/docs/fr/managed-agents/overview)

* Disponibilité : Non disponible
* Utilisation : Définissez plutôt l’effort pour une session en remplaçant les paramètres de modèle de l’agent.

### En-têtes bêta requis

[Présentation des en-têtes bêta](https://platform.claude.com/docs/fr/api/beta-headers)

Les en-têtes bêta vous permettent d’accéder à des fonctionnalités expérimentales et à de nouvelles capacités des modèles avant qu’elles ne fassent partie de l’API standard.

* `mid-conversation-output-config-2026-07-01`