---
title: Outil d'utilisation de l'ordinateur
url: https://platform.claude.com/docs/fr/agents-and-tools/tool-use/computer-use-tool
description: Donnez à Claude le contrôle des captures d'écran, de la souris et du clavier d'un environnement de bureau avec l'outil d'utilisation de l'ordinateur, l'ensemble d'outils client computer_toolset_20260801.
featureMetadata:
betaHeader: computer-use-2025-11-24, computer-use-2025-01-24
zdr:
eligibility: eligible
note: Excludes [Covered Models](https://platform.claude.com/docs/en/manage-claude/api-and-data-retention#model-specific-data-retention-requirements). Outil côté client dont les captures d’écran et les fichiers sont capturés et stockés dans votre environnement, et non par Anthropic.
supportedModels:
- claude-fable-5-2
- claude-mythos-5-2
- claude-fable-5-1
- claude-mythos-5-1
- claude-fable-5
- claude-mythos-5
- claude-mythos-preview
- claude-opus-5-5
- claude-opus-5
- claude-sonnet-5-5
- claude-sonnet-5
- claude-haiku-5-5
- claude-haiku-4-5-20251001
- claude-opus-4-8
- claude-opus-4-7
- claude-opus-4-6
- claude-sonnet-4-6
- claude-opus-4-5-20251101
- claude-sonnet-4-5-20250929
supportedPlatforms:
Claude API: stable
Claude Platform on AWS: stable
Amazon Bedrock: stable
Amazon Bedrock (InvokeModel): beta
Claude Models on Google Cloud (Google managed): stable
Microsoft Foundry: stable
details:
- Claude Fable 5.2, Claude Mythos 5.2, Claude Opus 5.5, Claude Sonnet 5.5 et Claude Haiku 5.5 prennent en charge l'utilisation de l'ordinateur via l'ensemble d'outils `computer_toolset_20260801`. Ils renvoient une erreur 400 pour toute version de l'outil d'utilisation de l'ordinateur qu'ils n'acceptent pas, comme `computer_20251124` sur l'API Claude. Pour migrer une intégration `computer_20251124` vers l'ensemble d'outils, consultez [Migrer depuis `computer_20251124`](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/computer-use-tool#migrate-from-computer-20251124). Pour migrer depuis `computer_20250124`, consultez [Passer l'utilisation de l'ordinateur à l'ensemble d'outils](https://platform.claude.com/docs/fr/models/haiku-5-5/migration-guide#computer-use-toolset) dans le guide de migration de Claude Haiku 5.5.
- Claude Opus 4.7, Claude Opus 4.6, Claude Sonnet 4.6 et Claude Opus 4.5 prennent en charge l'utilisation de l'ordinateur uniquement via la version de l'outil `computer_20251124`, qui nécessite un en-tête bêta ; consultez [Versions antérieures de l'outil](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/computer-use-tool#earlier-tool-versions).
---
**Commencez avec les ensembles d’outils du SDK :** pour `computer_toolset_20260801`, les SDK Python et TypeScript disposent d’une classe d’ensemble d’outils d’ordinateur, en bêta. Partez de [l’intégration d’un partenaire](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/browser-use-sdk#partner-integrations), ou consultez la section [ensemble d’outils de l’ordinateur](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/browser-use-sdk#computer-toolset) de la page sur les ensembles d’outils du SDK. Utilisez cette page comme référence de l’outil, ou lorsque vous gérez vous-même les appels d’outils.
Claude peut interagir avec des environnements informatiques grâce à l’outil d’utilisation de l’ordinateur (« computer use »), qui fournit des capacités de capture d’écran et le contrôle de la souris et du clavier pour une interaction autonome avec le bureau.
L’outil d’utilisation de l’ordinateur est un « [client toolset](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/tool-reference#client-toolsets) » (ensemble d’outils client) défini par Anthropic : une seule entrée `{"type": "computer_toolset_20260801"}` dans `tools` donne à Claude 17 outils membres tels que `screenshot`, `left_click`, `type` et `zoom`, et votre application exécute chaque appel dans un environnement que vous contrôlez. Il n’est actuellement pas disponible dans [Claude Managed Agents](https://platform.claude.com/docs/fr/managed-agents/tools). Les appels de Claude sont des blocs `tool_use` dont le `name` est le membre et qui portent `"toolset_name": "computer"`, souvent plusieurs en un seul tour (une [« batch action » (action groupée)](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/computer-use-tool#batch-actions)).
Pour les tâches qui restent à l’intérieur de pages web, l’[outil d’utilisation du navigateur](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/browser-use-tool) est plus adapté : ses outils membres lisent la page elle-même et agissent sur elle, et il ne nécessite pas d’environnement de bureau complet.
Consultez [Prise en charge de l’API](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/computer-use-tool#availability-feature-support) pour connaître les modèles et les plateformes qui prennent en charge l’ensemble d’outils. [Versions antérieures de l’outil](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/computer-use-tool#earlier-tool-versions) répertorie l’en-tête bêta de chaque version antérieure ainsi que les modèles avec lesquels l’utiliser.
## Considérations de sécurité
L’utilisation de l’ordinateur présente des risques uniques, distincts de ceux des fonctionnalités standard de l’API. Ces risques sont accrus lors d’interactions avec Internet.
Pour minimiser les risques, envisagez de prendre des précautions telles que :
1. Utiliser une machine virtuelle ou un conteneur dédié disposant de privilèges minimaux afin d’éviter les attaques directes sur le système ou les accidents.
2. Éviter de donner au modèle l’accès à des données sensibles, telles que des informations de connexion à des comptes, afin d’empêcher le vol d’informations.
3. Limiter l’accès à Internet à une liste autorisée de domaines afin de réduire l’exposition à du contenu malveillant.
4. Demander à un humain de confirmer les décisions susceptibles d’avoir des conséquences significatives dans le monde réel, ainsi que toute tâche nécessitant un consentement explicite, comme l’acceptation de cookies, la réalisation de transactions financières ou l’acceptation de conditions d’utilisation.
Dans certaines circonstances, Claude suit des commandes trouvées dans le contenu même lorsqu’elles entrent en conflit avec vos instructions. Par exemple, des instructions figurant sur des pages web ou contenues dans des images peuvent prendre le pas sur vos instructions ou amener Claude à commettre des erreurs. Prenez des précautions pour isoler Claude des données et actions sensibles afin d’éviter les risques liés à la « prompt injection » (injection de prompt).
Anthropic a entraîné le modèle à résister à ces injections de prompt et a ajouté une couche de défense supplémentaire. Si vous utilisez l’outil d’utilisation de l’ordinateur, des classificateurs analysent automatiquement ce que renvoie l’outil, comme les captures d’écran, afin de signaler d’éventuelles injections de prompt. Lorsque ces classificateurs identifient une injection de prompt potentielle, ils orientent le modèle pour qu’il vérifie si l’instruction provient réellement de vous avant d’y donner suite.
Cette protection supplémentaire n’est pas idéale pour tous les cas d’utilisation (par exemple, les cas d’utilisation sans humain dans la boucle) ; si vous souhaitez donc la refuser et la désactiver, [contactez le support](https://support.claude.com/en/). Les précautions énumérées précédemment restent importantes même avec ces classificateurs en place.
Informez les utilisateurs finaux des risques pertinents et obtenez leur consentement avant d’activer l’utilisation de l’ordinateur dans vos propres produits.
## Démarrage rapide
Ajoutez l’ensemble d’outils d’utilisation de l’ordinateur au tableau `tools` d’une requête de l’[API Messages](https://platform.claude.com/docs/fr/api/messages/create) sous la forme `{"type": "computer_toolset_20260801"}`. La requête ne nécessite aucun en-tête bêta. Cet exemple déclare également l’[outil d’éditeur de texte](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/text-editor-tool) et l’[outil bash](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/bash-tool), que Claude utilise généralement en complément de l’utilisation de l’ordinateur :
```bash cURL
curl https://api.anthropic.com/v1/messages \
-H "content-type: application/json" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2026-10-21" \
-d '{
"model": "claude-opus-5-5",
"max_tokens": 1024,
"tools": [
{
"type": "computer_toolset_20260801"
},
{
"type": "text_editor_20250728",
"name": "str_replace_based_edit_tool"
},
{
"type": "bash_20250124",
"name": "bash"
}
],
"messages": [
{
"role": "user",
"content": "Save a picture of a cat to my desktop."
}
]
}'
```
```bash CLI
ant messages create <<'YAML'
model: claude-opus-5-5
max_tokens: 1024
tools:
- type: computer_toolset_20260801
- type: text_editor_20250728
name: str_replace_based_edit_tool
- type: bash_20250124
name: bash
messages:
- role: user
content: Save a picture of a cat to my desktop.
YAML
```
```python Python
client = anthropic.Anthropic()
response = client.messages.create(
model="claude-opus-5-5",
max_tokens=1024,
tools=[
{"type": "computer_toolset_20260801"},
{"type": "text_editor_20250728", "name": "str_replace_based_edit_tool"},
{"type": "bash_20250124", "name": "bash"},
],
messages=[{"role": "user", "content": "Save a picture of a cat to my desktop."}],
)
print(response)
```
```typescript TypeScript
const client = new Anthropic();
const response = await client.messages.create({
model: "claude-opus-5-5",
max_tokens: 1024,
tools: [
{
type: "computer_toolset_20260801"
},
{
type: "text_editor_20250728",
name: "str_replace_based_edit_tool"
},
{
type: "bash_20250124",
name: "bash"
}
],
messages: [{ role: "user", content: "Save a picture of a cat to my desktop." }]
});
console.log(response);
```
```csharp C#
var client = new AnthropicClient();
var parameters = new MessageCreateParams
{
Model = Model.ClaudeOpus5_5,
MaxTokens = 1024,
Tools =
[
new ComputerToolset20260801(),
new ToolTextEditor20250728(),
new ToolBash20250124(),
],
Messages = [new UserMessageParam { Content = "Save a picture of a cat to my desktop." }],
};
var response = await client.Messages.Create(parameters);
Console.WriteLine(response);
```
```go Go
client := anthropic.NewClient()
response, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
Model: anthropic.ModelClaudeOpus5_5,
MaxTokens: 1024,
Tools: []anthropic.ToolUnionParam{
{OfComputerToolset20260801: &anthropic.ComputerToolset20260801Param{}},
{OfTextEditor20250728: &anthropic.ToolTextEditor20250728Param{}},
{OfBashTool20250124: &anthropic.ToolBash20250124Param{}},
},
Messages: []anthropic.MessageParam{
anthropic.NewUserMessage(anthropic.NewTextBlock("Save a picture of a cat to my desktop.")),
},
})
if err != nil {
log.Fatal(err)
}
fmt.Println(response.RawJSON())
```
```java Java
import com.anthropic.models.messages.ComputerToolset20260801;
// ...
import com.anthropic.models.messages.ToolBash20250124;
import com.anthropic.models.messages.ToolTextEditor20250728;
void main() {
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
MessageCreateParams params = MessageCreateParams.builder()
.model(Model.CLAUDE_OPUS_5_5)
.maxTokens(1024L)
.addTool(ComputerToolset20260801.builder().build())
.addTool(ToolTextEditor20250728.builder().build())
.addTool(ToolBash20250124.builder().build())
.addUserMessage("Save a picture of a cat to my desktop.")
.build();
Message response = client.messages().create(params);
IO.println(response);
}
```
```php PHP
$client = new Client();
$response = $client->messages->create(
maxTokens: 1024,
messages: [
['role' => 'user', 'content' => 'Save a picture of a cat to my desktop.'],
],
model: Model::CLAUDE_OPUS_5_5,
tools: [
['type' => 'computer_toolset_20260801'],
[
'type' => 'text_editor_20250728',
'name' => 'str_replace_based_edit_tool',
],
[
'type' => 'bash_20250124',
'name' => 'bash',
],
],
);
echo $response;
```
```ruby Ruby
client = Anthropic::Client.new
response = client.messages.create(
model: Anthropic::Model::CLAUDE_OPUS_5_5,
max_tokens: 1024,
tools: [
{ type: "computer_toolset_20260801" },
{
type: "text_editor_20250728",
name: "str_replace_based_edit_tool"
},
{
type: "bash_20250124",
name: "bash"
}
],
messages: [
{ role: "user", content: "Save a picture of a cat to my desktop." }
]
)
puts response
```
Lorsque Claude agit sur le bureau, la réponse a un `stop_reason` égal à `tool_use` et contient un ou plusieurs blocs `tool_use` de membres, chacun nommant un outil membre et portant `"toolset_name": "computer"`. Au milieu de cette tâche, après que Claude a reçu une capture d’écran du bureau, une réponse pourrait ressembler à ceci :
```json Output
{
"id": "msg_01UZ3bXcQH8mTqNhVfL9eK2p",
"type": "message",
"role": "assistant",
"model": "claude-opus-5-5",
"content": [
{
"type": "text",
"text": "I'll open the web browser to find a picture of a cat."
},
{
"type": "tool_use",
"id": "toolu_01WkoTUvSHDzTBu2xnGk8Ep8",
"name": "left_click",
"toolset_name": "computer",
"input": { "coordinate": [512, 742] }
},
{
"type": "tool_use",
"id": "toolu_017nJn3RgSCkTMwuZDb4uUov",
"name": "screenshot",
"toolset_name": "computer",
"input": {}
}
],
"stop_reason": "tool_use",
"stop_sequence": null
}
```
Votre application exécute chaque appel dans l’ordre dans votre propre environnement, renvoie un bloc `tool_result` pour chaque bloc `tool_use`, puis appelle à nouveau l’API ; [Fonctionnement de l’utilisation de l’ordinateur](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/computer-use-tool#how-computer-use-works) décrit cette boucle, et le reste de cette page montre comment l’implémenter.
***
## Fonctionnement de l’utilisation de l’ordinateur
* Ajoutez l’ensemble d’outils d’utilisation de l’ordinateur (et éventuellement d’autres outils) au tableau `tools` de votre requête API.
* Incluez un prompt utilisateur qui nécessite une interaction avec le bureau, par exemple : « Enregistre une image de chat sur mon bureau. »
* Claude évalue si agir sur le bureau peut aider à répondre à la requête de l’utilisateur.
* Si c’est le cas, Claude répond avec un ou plusieurs blocs `tool_use` de membres, tels que `screenshot`, `left_click` ou `type`, chacun portant `"toolset_name": "computer"`. Une réponse contenant plusieurs de ces blocs est une [action groupée](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/computer-use-tool#batch-actions).
* La réponse de l’API a un `stop_reason` égal à `tool_use`, ce qui signale une demande d’utilisation d’outils.
* Parcourez chaque bloc `tool_use` de la réponse, dans l’ordre. Pour chacun, effectuez la répartition selon le `name` du membre conjointement avec `toolset_name`, et réalisez cette action avec l’`input` du bloc sur votre conteneur ou votre machine virtuelle.
* Poursuivez la conversation avec un nouveau message `user` contenant un bloc `tool_result` pour chaque bloc `tool_use`, associé par `tool_use_id` et reprenant chacun `"toolset_name": "computer"`. Renvoyez une image pour `screenshot` et `zoom` ; un texte court tel que `OK` suffit pour les autres actions.
* Si une action échoue, renvoyez `is_error: true` pour ce bloc et répondez au reste du lot comme décrit dans [Actions groupées](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/computer-use-tool#batch-actions).
* Claude analyse les résultats des outils pour déterminer si d’autres actions sont nécessaires ou si la tâche est terminée.
* Si Claude détermine que d’autres actions sont nécessaires, il répond avec un autre `stop_reason` `tool_use` ; revenez à l’étape 3.
* Sinon, il renvoie une réponse textuelle à l’utilisateur.
Les étapes 3 et 4, répétées sans intervention de l’utilisateur, forment l’« agent loop » (boucle d’agent) : Claude répond avec une demande d’utilisation d’outils, et votre application répond à Claude avec les résultats de l’évaluation de cette demande.
### Actions groupées
Claude peut planifier une courte séquence d’actions, par exemple cliquer, saisir du texte, puis prendre une capture d’écran, et les renvoyer ensemble dans une seule réponse. C’est ce qu’on appelle une action groupée ; elle utilise la même forme de réponse que l’[utilisation d’outils en parallèle](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/parallel-tool-use), à une différence près : vous exécutez les blocs dans l’ordre plutôt que simultanément.
Une réponse avec un lot de trois actions ressemble à ceci :
```json
{
"role": "assistant",
"content": [
{
"type": "tool_use",
"id": "toolu_01HqCF3nJ4Vzr8sTkPZ2wxYA",
"name": "left_click",
"toolset_name": "computer",
"input": { "coordinate": [640, 60] }
},
{
"type": "tool_use",
"id": "toolu_01Ppr3sZ3TnE9m6VUu4RyH2K",
"name": "type",
"toolset_name": "computer",
"input": { "text": "pictures of cats" }
},
{
"type": "tool_use",
"id": "toolu_01Xf5W1sD8Q9aBcJ7kLmN2pQ",
"name": "screenshot",
"toolset_name": "computer",
"input": {}
}
]
}
```
Renvoyez un bloc `tool_result` pour chaque bloc `tool_use`, associé par `tool_use_id`, tous dans le message `user` suivant. Chaque résultat pour un outil membre doit porter `"toolset_name": "computer"` ; un résultat qui l’omet, ou qui nomme un ensemble d’outils différent de celui de son bloc `tool_use`, est rejeté. Seuls les résultats de `screenshot` et `zoom` nécessitent une image ; pour les autres membres, un court accusé de réception textuel tel que `OK` suffit (`cursor_position` renvoie les coordonnées sous forme de texte) :
```json
{
"role": "user",
"content": [
{
"type": "tool_result",
"tool_use_id": "toolu_01HqCF3nJ4Vzr8sTkPZ2wxYA",
"toolset_name": "computer",
"content": [{ "type": "text", "text": "OK" }]
},
{
"type": "tool_result",
"tool_use_id": "toolu_01Ppr3sZ3TnE9m6VUu4RyH2K",
"toolset_name": "computer",
"content": [{ "type": "text", "text": "OK" }]
},
{
"type": "tool_result",
"tool_use_id": "toolu_01Xf5W1sD8Q9aBcJ7kLmN2pQ",
"toolset_name": "computer",
"content": [
{
"type": "image",
"source": {
"type": "base64",
"media_type": "image/png",
"data": "iVBORw0KGgo..."
}
}
]
}
]
}
```
**Exécutez les blocs dans l’ordre et arrêtez-vous au premier échec.** Les actions ultérieures d’un lot dépendent généralement des précédentes : dans cet exemple, le `type` saisit du texte dans l’élément auquel le clic précédent a donné le focus. Exécutez les blocs séquentiellement dans l’ordre où ils apparaissent dans `content`, et si l’un d’eux échoue, n’exécutez pas les suivants. Chaque bloc `tool_use` a tout de même besoin d’un `tool_result` ; répondez donc au lot comme suit :
* Pour chaque action réussie, renvoyez son résultat normal.
* Pour l’action qui a échoué, renvoyez `is_error: true` avec une description textuelle de ce qui s’est mal passé.
* Pour chaque action ultérieure du lot, renvoyez `is_error: true` avec exactement ce texte (l’outil d’utilisation du navigateur utilise son propre [texte d’arrêt](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/browser-use-tool#batch-actions)) :
```json
{
"type": "tool_result",
"tool_use_id": "toolu_01Xf5W1sD8Q9aBcJ7kLmN2pQ",
"toolset_name": "computer",
"is_error": true,
"content": "Not executed: an earlier computer action in this turn failed."
}
```
Claude lit alors quelles actions ont réussi, laquelle a échoué et lesquelles ont été ignorées, puis replanifie lors de son tour suivant. Une requête qui laisse un bloc `tool_use` du lot sans réponse est rejetée avec une `invalid_request_error` ; une boucle d’agent qui ne lit que le premier bloc échoue donc lors de son appel suivant. Si votre application demande à un humain de confirmer les actions lourdes de conséquences, effectuez cette vérification avant l’exécution de chaque bloc, car un lot peut accomplir une action en plusieurs étapes en un seul tour.
Claude termine généralement un lot par `screenshot` afin d’observer le résultat avant de déterminer la suite. Lorsqu’un lot ne se termine pas par une capture d’écran, votre application peut joindre une capture d’écran sous forme de bloc `image` supplémentaire au dernier résultat du lot, afin que Claude reçoive toujours l’état actuel de l’écran, ce qui économise un aller-retour par rapport à l’attente d’une demande de Claude. Vous pouvez également demander à Claude, via le prompt, de terminer chaque lot par une capture d’écran (consultez [Optimiser les performances du modèle avec le prompting](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/computer-use-tool#optimize-model-performance-with-prompting)).
### L’environnement informatique
L’utilisation de l’ordinateur nécessite un environnement informatique isolé (« sandbox ») dans lequel Claude peut interagir en toute sécurité avec des applications et le web. Cet environnement comprend :
1. **Affichage virtuel :** un serveur d’affichage X11 virtuel (utilisant Xvfb) qui effectue le rendu de l’interface de bureau que Claude reçoit sous forme de captures d’écran et contrôle par des actions de souris et de clavier.
2. **Environnement de bureau :** une interface légère avec un gestionnaire de fenêtres (Mutter) et un panneau (Tint2) fonctionnant sous Linux, qui fournit une interface graphique cohérente avec laquelle Claude peut interagir.
3. **Applications :** des applications Linux préinstallées telles que Firefox, LibreOffice, des éditeurs de texte et des gestionnaires de fichiers que Claude peut utiliser pour accomplir des tâches.
4. **Implémentations des outils :** du code d’intégration qui traduit les demandes d’outils abstraites de Claude (comme « déplacer la souris » ou « prendre une capture d’écran ») en opérations réelles dans l’environnement virtuel.
5. **Boucle d’agent :** un programme qui gère la communication entre Claude et l’environnement, en envoyant les actions de Claude à l’environnement et en renvoyant les résultats (captures d’écran, sorties de commandes) à Claude.
Lorsque vous utilisez l’utilisation de l’ordinateur, Claude ne se connecte pas directement à cet environnement. À la place, votre application :
1. Reçoit les demandes d’utilisation d’outils de Claude.
2. Les traduit en actions dans votre environnement informatique.
3. Capture les résultats (comme les captures d’écran et les sorties de commandes).
4. Renvoie ces résultats à Claude.
Pour des raisons de sécurité et d’isolation, l’implémentation de référence exécute tout cela à l’intérieur d’un conteneur Docker avec des mappages de ports appropriés pour visualiser l’environnement et interagir avec lui.
***
## Comment implémenter l’utilisation de l’ordinateur
Vous mettez à niveau une intégration `computer_20251124` existante ? Commencez par [Migrer depuis `computer_20251124`](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/computer-use-tool#migrate-from-computer-20251124) ; le reste de cette section s’applique aussi bien aux nouvelles intégrations qu’aux intégrations migrées.
L’[implémentation de référence de l’utilisation de l’ordinateur](https://github.com/anthropics/claude-quickstarts/tree/main/computer-use-demo) est un exemple complet et fonctionnel : un [environnement conteneurisé](https://github.com/anthropics/claude-quickstarts/blob/main/computer-use-demo/Dockerfile) adapté à l’utilisation de l’ordinateur, des implémentations des [outils d’utilisation de l’ordinateur](https://github.com/anthropics/claude-quickstarts/tree/main/computer-use-demo/computer_use_demo/tools), une [boucle d’agent](https://github.com/anthropics/claude-quickstarts/blob/main/computer-use-demo/computer_use_demo/loop.py) qui appelle l’API Claude et exécute les outils, ainsi qu’une interface web pour le conteneur, la boucle et les outils. Pour utiliser `computer_toolset_20260801`, choisissez un [modèle qui le prend en charge](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/computer-use-tool#availability-feature-support), puis sélectionnez l’ensemble d’outils sous **Tool Versions** dans la barre latérale de l’interface web.
### Comprendre la boucle d’agent
Le cœur de l’utilisation de l’ordinateur est la « boucle d’agent » : un cycle dans lequel Claude demande des actions d’outils, et votre application les exécute et renvoie les résultats à Claude. La boucle utilise le client que vous avez créé dans le [Démarrage rapide](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/computer-use-tool#quick-start), un tableau `tools` qui ne déclare que l’ensemble d’outils d’utilisation de l’ordinateur, et la fonction utilitaire de traitement des appels d’outils décrite sous [Implémenter l’outil d’utilisation de l’ordinateur](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/computer-use-tool#implement-the-computer-use-tool). Si vous déclarez également d’autres outils, comme les outils bash et d’éditeur de texte du Démarrage rapide, répartissez leurs blocs `tool_use` dans la même passe ; la fonction utilitaire ne répond qu’aux appels de membres de l’utilisation de l’ordinateur, et la boucle considère qu’un tour sans aucun appel traité est terminé. Voici un exemple simplifié :
```python Python
def sampling_loop(model: str, messages: list[MessageParam], max_iterations: int = 10):
"""
Run the computer-use agent loop until Claude stops requesting tools
or the iteration limit is reached.
"""
for _ in range(max_iterations):
response = client.messages.create(
model=model,
max_tokens=4096,
messages=messages,
tools=TOOLS,
)
# Ajouter la réponse de Claude à l'historique de la conversation.
messages.append({"role": "assistant", "content": response.content})
# Exécuter les actions demandées par Claude, dans l'ordre, et collecter les résultats.
tool_results = process_tool_calls(response)
if not tool_results:
return messages # No more tool use; task complete
# Renvoyer tous les résultats à Claude dans un seul message utilisateur.
messages.append({"role": "user", "content": tool_results})
return messages
```
```typescript TypeScript
async function samplingLoop(
model: string,
messages: Anthropic.MessageParam[],
maxIterations = 10
): Promise {
// Exécuter la boucle d'agent computer-use jusqu'à ce que Claude cesse de demander des outils
// ou que la limite d'itérations soit atteinte.
for (let i = 0; i < maxIterations; i++) {
const response = await client.messages.create({
model,
max_tokens: 4096,
messages,
tools
});
// Ajouter la réponse de Claude à l'historique de la conversation
messages.push({ role: "assistant", content: response.content });
// Exécuter les outils demandés par Claude et collecter les résultats
const toolResults = processToolCalls(response);
if (toolResults.length === 0) {
return messages; // No more tool use; task complete
}
// Renvoyer les résultats d'outils à Claude pour l'itération suivante
messages.push({ role: "user", content: toolResults });
}
return messages;
}
```
```csharp C#
async Task> SamplingLoop(
Model model,
List messages,
int maxIterations = 10
)
{
// Exécuter la boucle d'agent computer-use jusqu'à ce que Claude cesse de demander des outils
// ou que la limite d'itérations soit atteinte.
for (var i = 0; i < maxIterations; i++)
{
var response = await client.Messages.Create(
new MessageCreateParams
{
Model = model,
MaxTokens = 4096,
Messages = messages,
Tools = tools,
}
);
// Ajouter la réponse de Claude à l'historique de la conversation
messages.Add(
new AssistantMessageParam
{
Content = response
.Content.Select(block => new ContentBlockParam(block.Json))
.ToList(),
}
);
// Exécuter les outils demandés par Claude et collecter les résultats
var toolResults = ProcessToolCalls(response);
if (toolResults.Count == 0)
{
return messages; // No more tool use; task complete
}
// Renvoyer les résultats d'outils à Claude pour l'itération suivante
messages.Add(new UserMessageParam { Content = toolResults });
}
return messages;
}
```
```go Go
// samplingLoop exécute la boucle d'agent computer-use jusqu'à ce que Claude cesse
// de demander des outils ou que la limite d'itérations soit atteinte.
func samplingLoop(ctx context.Context, model anthropic.Model, messages []anthropic.MessageParam, maxIterations int) ([]anthropic.MessageParam, error) {
for range maxIterations {
response, err := client.Messages.New(ctx, anthropic.MessageNewParams{
Model: model,
MaxTokens: 4096,
Messages: messages,
Tools: tools,
})
if err != nil {
return nil, err
}
// Ajouter la réponse de Claude à l'historique de la conversation
messages = append(messages, response.ToParam())
// Exécuter dans l'ordre les actions demandées par Claude et collecter les résultats
toolResults := processToolCalls(response)
if len(toolResults) == 0 {
return messages, nil // No more tool use; task complete
}
// Renvoyer tous les résultats à Claude dans un seul message utilisateur
messages = append(messages, anthropic.NewUserMessage(toolResults...))
}
return messages, nil
}
```
```java Java
/**
* Run the computer-use agent loop until Claude stops requesting tools
* or the iteration limit is reached.
*/
List samplingLoop(Model model, List messages, int maxIterations) {
for (int i = 0; i < maxIterations; i++) {
Message response = client.messages().create(MessageCreateParams.builder()
.model(model)
.maxTokens(4096)
.messages(messages)
.addTool(COMPUTER_TOOLSET)
.build());
// Ajouter la réponse de Claude à l'historique de la conversation
messages.add(response.toParam());
// Exécuter les outils demandés par Claude et collecter les résultats
List toolResults = processToolCalls(response);
if (toolResults.isEmpty()) {
return messages; // No more tool use; task complete
}
// Renvoyer les résultats des outils à Claude pour l'itération suivante
messages.add(MessageParam.ofUserOfContentBlockParams(toolResults));
}
return messages;
}
```
```php PHP
/**
* Run the computer-use agent loop until Claude stops requesting tools
* or the iteration limit is reached.
*/
function samplingLoop(string $model, array $messages, int $maxIterations = 10): array
{
global $client, $tools;
for ($i = 0; $i < $maxIterations; $i++) {
$response = $client->messages->create(
model: $model,
maxTokens: 4096,
messages: $messages,
tools: $tools,
);
// Ajouter la réponse de Claude à l'historique de la conversation
$messages[] = MessageParam::with(role: Role::ASSISTANT, content: $response->content);
// Exécuter les outils demandés par Claude et collecter les résultats
$toolResults = processToolCalls($response);
if ($toolResults === []) {
return $messages; // No more tool use; task complete
}
// Renvoyer les résultats d'outils à Claude pour l'itération suivante
$messages[] = MessageParam::with(role: Role::USER, content: $toolResults);
}
return $messages;
}
```
```ruby Ruby
# Exécuter la boucle d'agent computer-use jusqu'à ce que Claude cesse de demander des outils
# ou que la limite d'itérations soit atteinte.
def sampling_loop(model, messages, max_iterations: 10)
max_iterations.times do
response = CLIENT.messages.create(
model: model,
max_tokens: 4096,
messages: messages,
tools: TOOLS
)
# Ajouter la réponse de Claude à l'historique de la conversation
messages << { role: "assistant", content: response.content }
# Exécuter dans l'ordre les actions demandées par Claude et collecter les résultats
tool_results = process_tool_calls(response)
return messages if tool_results.empty? # No more tool use; task complete
# Renvoyer tous les résultats à Claude dans un seul message utilisateur
messages << { role: "user", content: tool_results }
end
messages
end
```
La boucle se poursuit jusqu’à ce que Claude réponde sans demander d’outils (tâche terminée) ou que la limite maximale d’itérations soit atteinte. Cette protection évite d’éventuelles boucles infinies susceptibles d’entraîner des coûts d’API inattendus.
### Optimiser les performances du modèle avec le prompting
1. Spécifiez des tâches simples et bien définies, et fournissez des instructions explicites pour chaque étape.
2. Claude agit parfois comme si ses actions avaient réussi sans en vérifier explicitement les résultats. Pour éviter cela, vous pouvez donner à Claude le prompt suivant : `After each step, take a screenshot and carefully evaluate if you have achieved the right outcome. State in one sentence what the screenshot shows and whether the step succeeded. If it didn't, try again. Only when you confirm a step was executed correctly should you move on to the next one.`
3. Certains éléments d’interface (comme les listes déroulantes et les barres de défilement) peuvent être difficiles à manipuler pour Claude à l’aide de mouvements de souris. Si vous rencontrez ce problème, essayez de demander au modèle d’utiliser des raccourcis clavier.
4. Pour les tâches répétables ou les interactions avec l’interface, incluez dans votre prompt des exemples de captures d’écran et d’appels d’outils ayant abouti.
5. Si vous avez besoin que le modèle se connecte, fournissez-lui le nom d’utilisateur et le mot de passe dans votre prompt, à l’intérieur de balises XML telles que ``. Utiliser l’utilisation de l’ordinateur dans des applications nécessitant une connexion augmente le risque de mauvais résultats dus à l’injection de prompt. Consultez [Atténuer les jailbreaks et les injections de prompt](https://platform.claude.com/docs/fr/test-and-evaluate/strengthen-guardrails/mitigate-jailbreaks) avant de fournir au modèle des identifiants de connexion.
6. Lors de la construction du tableau `content` d’un tour utilisateur, placez le texte de l’instruction *avant* l’image de la capture d’écran. Fournir la description de la cible avant le traitement de l’image améliore la précision des clics.
7. Claude utilise l’action `zoom` pour inspecter une région en pleine résolution lorsqu’on l’interroge sur du petit texte ou des éléments d’interface spécifiques qui ne sont pas lisibles à la résolution par défaut de la capture d’écran, comme les noms de fichiers dans une barre latérale, les titres d’onglets, le texte de la barre d’état, les numéros de ligne ou les libellés de boutons. Si Claude ne zoome pas lorsque vous vous y attendez, posez une question sur une région ou un élément spécifique plutôt que sur l’écran dans son ensemble.
8. Si vous souhaitez que chaque [action groupée](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/computer-use-tool#batch-actions) se termine par une capture d’écran, indiquez-le dans l’invite système, par exemple : `End each group of actions with a screenshot so you can verify the result before continuing.`
Si vous rencontrez de manière répétée un ensemble clair de problèmes ou si vous connaissez à l’avance les tâches que Claude devra accomplir, utilisez l’invite système pour fournir à Claude des conseils ou des instructions explicites sur la façon de réussir ces tâches.
Pour les agents qui s’étendent sur plusieurs sessions, effectuez une vérification de bout en bout au début de chaque session, et pas seulement après l’implémentation. Les vérifications dans le navigateur détectent les régressions des sessions précédentes que la seule revue au niveau du code ne repère pas. Consultez [Effective harnesses for long-running agents](https://www.anthropic.com/engineering/effective-harnesses-for-long-running-agents) pour plus de détails.
### Invites système
Lorsque vous incluez l’outil d’utilisation de l’ordinateur dans une requête, l’API génère une invite système spécifique à l’utilisation de l’ordinateur. Elle est similaire à l’[invite système d’utilisation d’outils](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/define-tools#tool-use-system-prompt), mais commence par :
> You have access to a set of functions you can use to answer the user’s question. This includes access to a sandboxed computing environment. You do NOT currently have the ability to inspect files or interact with external resources, except by invoking the below functions.
Comme pour l’utilisation d’outils classique, le paramètre `system` fourni par l’utilisateur est toujours respecté et utilisé dans la construction de l’invite système combinée.
### Actions disponibles
Chaque action est un outil membre de l’ensemble d’outils d’utilisation de l’ordinateur : Claude nomme le membre dans un bloc `tool_use` qui porte `"toolset_name": "computer"`, et l’`input` du bloc ne contient que les paramètres de ce membre, sans champ `action`. L’ensemble d’outils comporte 17 outils membres :
| Membre | Entrée | Description |
| ------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `screenshot` | Aucune (`{}`) | Capture l’affichage complet et le renvoie sous forme d’image. |
| `zoom` | `region` : `[x0, y0, x1, y1]`, les coins supérieur gauche et inférieur droit de la zone à inspecter | Capture uniquement cette région de l’affichage en pleine résolution et la renvoie sous forme d’image, mise à l’échelle pour tenir dans vos dimensions de capture d’écran habituelles en conservant son rapport d’aspect. Cela permet à Claude de lire du petit texte ou une interface dense qui n’est pas lisible dans une capture d’écran complète réduite. |
| `left_click` | `coordinate` (facultatif) : `[x, y]` ; `text` (facultatif) : touches de modification à maintenir pendant le clic : `shift`, `ctrl`, `alt`, `super` (la touche Commande ou Windows), ou une combinaison jointe par `+` telle que `ctrl+shift` | Clique avec le bouton gauche de la souris à `coordinate`, ou à la position actuelle du curseur lorsque `coordinate` est omis. |
| `right_click`, `middle_click`, `double_click`, `triple_click` | Identique à `left_click` | Autres boutons de la souris et clics multiples. |
| `left_click_drag` | `start_coordinate` : `[x, y]` ; `coordinate` : `[x, y]` ; `text` (facultatif) : touches de modification | Appuie à `start_coordinate`, fait glisser jusqu’à `coordinate`, puis relâche. |
| `mouse_move` | `coordinate` : `[x, y]` | Déplace le curseur sans cliquer, par exemple pour survoler un élément. |
| `left_mouse_down`, `left_mouse_up` | Aucune (`{}`) | Appuie sur le bouton gauche de la souris ou le relâche à la position actuelle du curseur, pour les glissements que `left_click_drag` ne peut pas exprimer. Déplacez d’abord le curseur avec `mouse_move`. |
| `cursor_position` | Aucune (`{}`) | Indique la position `[x, y]` actuelle du curseur sous forme de texte. |
| `scroll` | `scroll_direction` : `"up"`, `"down"`, `"left"` ou `"right"` ; `scroll_amount` : nombre de crans de molette ; `coordinate` (facultatif) : `[x, y]` ; `text` (facultatif) : touches de modification | Fait défiler à `coordinate`, ou à la position actuelle du curseur. |
| `type` | `text` : la chaîne à saisir | Saisit du texte littéral à l’emplacement du focus clavier actuel. |
| `key` | `text` : une touche ou une combinaison jointe par `+` telle que `"Return"`, `"ctrl+s"` ou `"alt+Tab"` ; `repeat` (facultatif) : de 1 à 100, 1 par défaut | Appuie sur une touche ou une combinaison de touches, `repeat` fois. |
| `hold_key` | `text` : une touche ou une combinaison ; `duration` : en secondes, jusqu’à 300 | Maintient une touche enfoncée pendant la durée indiquée. |
| `wait` | `duration` : en secondes, jusqu’à 300 | Marque une pause avant l’action suivante, par exemple pendant le chargement d’une application. |
Gardez les points suivants à l’esprit lors de l’implémentation des membres :
* **Les coordonnées sont exprimées en pixels de capture d’écran.** Chaque valeur `coordinate`, `start_coordinate` et `region`, ainsi que la position indiquée par `cursor_position`, se situe dans l’espace de pixels des captures d’écran de l’affichage complet que vous renvoyez, avec l’origine en haut à gauche. Les images de zoom ne changent rien à cela : après un `zoom`, Claude exprime toujours les coordonnées dans l’espace de la capture d’écran complète, jamais par rapport à l’image zoomée. Si vous réduisez les captures d’écran avant de les renvoyer, remettez à l’échelle les coordonnées de Claude avant de les appliquer à l’affichage réel (consultez [Dimensionner les captures d’écran pour respecter les limites d’image](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/computer-use-tool#handle-coordinate-scaling-for-higher-resolutions)).
* **Tous les membres sont activés par défaut, y compris `zoom`.** Si votre environnement ne peut pas produire d’images de zoom, retirez le membre avec `configs` (consultez [Paramètres de l’outil](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/computer-use-tool#tool-parameters)) plutôt que de le laisser activé et de renvoyer des erreurs. Si Claude appelle un membre que vous avez retiré ou que vous n’implémentez pas, renvoyez un `tool_result` avec `is_error: true` pour ce bloc.
* **Effectuez la répartition selon la paire (`toolset_name`, `name`).** C’est `toolset_name` qui identifie un bloc comme une action sur l’ordinateur : un outil personnalisé de la même requête peut partager le nom d’un membre, et une version ultérieure de l’ensemble d’outils peut ajouter des membres (consultez [Ensembles d’outils client](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/tool-reference#client-toolsets)).
Chaque exemple est un bloc `tool_use` complet tel qu’il apparaît dans la réponse de Claude.
Maj+clic à une position, par exemple pour étendre une sélection. Contrairement à `hold_key`, `text` maintient les touches de modification uniquement pendant la durée de ce clic ou de ce défilement :
```json
{
"type": "tool_use",
"id": "toolu_01Qg8m3XqC5aRy7tD2eS4jUg",
"name": "left_click",
"toolset_name": "computer",
"input": { "coordinate": [500, 300], "text": "shift" }
}
```
Faire glisser d’un point à un autre :
```json
{
"type": "tool_use",
"id": "toolu_01Ed6j9VnA3yPw5rB8cQ2gSe",
"name": "left_click_drag",
"toolset_name": "computer",
"input": {
"start_coordinate": [200, 300],
"coordinate": [600, 300]
}
}
```
Faire défiler vers le bas de trois crans de molette :
```json
{
"type": "tool_use",
"id": "toolu_01Yc5h8UmZ2xNv4qA7bP9fRd",
"name": "scroll",
"toolset_name": "computer",
"input": {
"coordinate": [500, 400],
"scroll_direction": "down",
"scroll_amount": 3
}
}
```
Appuyer quatre fois sur Tab :
```json
{
"type": "tool_use",
"id": "toolu_01Sb4g7TkY9wLu3pX6zM8eQc",
"name": "key",
"toolset_name": "computer",
"input": { "text": "Tab", "repeat": 4 }
}
```
Zoomer pour inspecter une région en pleine résolution :
```json
{
"type": "tool_use",
"id": "toolu_01Kf7k2WpB4zQx6sC9dR3hTf",
"name": "zoom",
"toolset_name": "computer",
"input": { "region": [100, 200, 400, 350] }
}
```
Indiquer la position du curseur. Répondez à cet appel avec un court résultat textuel qui donne la position en pixels de capture d’écran, par exemple `X=512, Y=384` :
```json
{
"type": "tool_use",
"id": "toolu_01Ekh3vqB6yTs2mNc4Rw8pLd",
"name": "cursor_position",
"toolset_name": "computer",
"input": {}
}
```
### Paramètres de l’outil
L’entrée de l’ensemble d’outils dans le tableau `tools` accepte quatre paramètres ; les règles qu’ils partagent avec l’ensemble d’outils d’utilisation du navigateur sont énumérées sous [Ensembles d’outils client](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/tool-reference#client-toolsets).
| Paramètre | Obligatoire | Description |
| ----------------- | ----------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `type` | Oui | `computer_toolset_20260801` |
| `configs` | Non | Paramètres par membre, indexés par nom de membre ; chaque membre accepte `enabled` (par défaut `true` pour les 17, y compris `zoom`) et `defer_loading` (par défaut `false`, pour la [recherche d’outils](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/tool-search-tool#deferred-tool-loading)), et les membres que vous omettez conservent leurs valeurs par défaut. |
| `cache_control` | Non | Point d’arrêt de [mise en cache des prompts](https://platform.claude.com/docs/fr/build-with-claude/prompt-caching) au niveau de la définition de l’ensemble d’outils ; sur l’entrée uniquement. Un point d’arrêt sur un bloc `tool_use` ou `tool_result` d’un lot prend effet à la fin de ce lot ; consultez [Utilisation d’outils avec la mise en cache des prompts](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/tool-use-with-prompt-caching#cache-control-on-tool-definitions). |
| `allowed_callers` | Non | `["direct"]` uniquement. |
Par exemple, cette entrée retire `zoom` pour un environnement qui ne l’implémente pas et définit un point d’arrêt de cache au niveau de la définition de l’ensemble d’outils :
```json
{
"type": "computer_toolset_20260801",
"configs": {
"zoom": { "enabled": false }
},
"cache_control": { "type": "ephemeral" }
}
```
Si votre boucle d’agent ne peut exécuter qu’une seule action par aller-retour, définissez `disable_parallel_tool_use` sur `true` dans `tool_choice` ; Claude renvoie alors au plus un bloc `tool_use` de membre par tour (consultez [Désactiver l’utilisation d’outils en parallèle](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/parallel-tool-use#disable-parallel-tool-use)).
L’entrée rejette ces paramètres issus des versions d’outil antérieures, et une requête qui inclut l’un d’eux renvoie une `invalid_request_error` :
* `name` : les noms des membres sont fixés par la version de l’ensemble d’outils.
* `display_width_px`, `display_height_px` et `display_number` : les coordonnées sont toujours exprimées dans l’espace de pixels des captures d’écran que vous renvoyez.
* `enable_zoom` : zoom est un outil membre que vous contrôlez via `configs`.
L’entrée ne peut pas non plus être déclarée dans la même requête qu’une entrée `computer_20251124` ou qu’un autre outil nommé `computer`. Pour `strict`, `input_examples`, l’emplacement de `defer_loading`, `tool_choice`, le streaming et les restrictions d’appelants, consultez [Ensembles d’outils client](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/tool-reference#client-toolsets).
### Combinaison avec la réflexion
Pour combiner l’utilisation de l’ordinateur avec la réflexion, consultez [Réflexion](https://platform.claude.com/docs/fr/build-with-claude/thinking).
Pour l’outil `computer_20251124`, les évaluations internes sur les modèles qui l’utilisent suggèrent ces paramètres `effort` :
* **Claude Opus 4.7 :** utilisez `high` par défaut ; utilisez `low` pour les charges de travail à haut débit ou sensibles aux coûts.
* **Claude Sonnet 4.6 et Claude Opus 4.6 :** utilisez `medium` par défaut (meilleur rapport précision/coût). Évitez `max`, qui ajoute un coût en tokens sans améliorer la précision sur les tâches d’interface. Sur ces modèles, `low` utilise *moins* de tokens de sortie que la désactivation complète de la réflexion (moins d’erreurs signifie moins de nouvelles tentatives), ce qui en fait une option intéressante pour les boucles sensibles aux coûts.
### Enrichir l’utilisation de l’ordinateur avec d’autres outils
Pour ajouter d’autres outils en complément de l’utilisation de l’ordinateur, incluez-les dans le même tableau `tools`. La section [Démarrage rapide](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/computer-use-tool#quick-start) illustre ce modèle avec l’[outil bash](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/bash-tool) et l’[outil d’éditeur de texte](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/text-editor-tool). Vous pouvez ajouter vos propres [définitions d’outils personnalisés](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/define-tools) de la même manière.
Pour les tâches qui restent à l’intérieur de pages web, vous pouvez également [déclarer l’outil d’utilisation du navigateur dans la même requête](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/browser-use-tool#combine-with-other-tools). Les deux ensembles d’outils fonctionnent indépendamment, chacun dans son propre repère de coordonnées. La valeur `toolset_name` permet de distinguer les appels à des membres qui partagent un nom, comme `screenshot` ou `key`.
### Créer un environnement personnalisé d’utilisation de l’ordinateur
L’[implémentation de référence](https://github.com/anthropics/claude-quickstarts/tree/main/computer-use-demo) est destinée à vous aider à démarrer avec l’utilisation de l’ordinateur. Elle inclut tous les composants nécessaires pour que Claude utilise un ordinateur. Toutefois, vous pouvez créer votre propre environnement d’utilisation de l’ordinateur adapté à vos besoins. Vous avez besoin de :
* Un environnement virtualisé ou conteneurisé adapté à l’utilisation de l’ordinateur avec Claude
* Une implémentation des actions de l’outil d’utilisation de l’ordinateur
* Une boucle d’agent qui interagit avec l’API Claude et exécute les résultats `tool_use` à l’aide de vos implémentations d’outils
* Une API ou une interface utilisateur qui permet une saisie de l’utilisateur pour démarrer la boucle d’agent
### Implémenter l’outil d’utilisation de l’ordinateur
L’outil d’utilisation de l’ordinateur est implémenté comme un outil sans schéma. Lorsque vous utilisez cet outil, vous n’avez pas besoin de fournir un schéma d’entrée comme pour les autres outils ; le schéma est intégré au modèle de Claude et ne peut pas être modifié.
Créez un affichage virtuel ou connectez-vous à un affichage existant avec lequel Claude interagit. Cela implique généralement la configuration de Xvfb (X Virtual Framebuffer) ou d’une technologie similaire.
Créez des fonctions pour gérer chaque type d’action que Claude pourrait demander :
```python Python
# Données d'image factices ; un exécuteur réel capture l'écran et renvoie les octets PNG.
PLACEHOLDER_PNG = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg=="
def capture_screenshot() -> list[ImageBlockParam]:
# screenshot répond avec un bloc image plutôt que du texte : renvoyer la liste de contenu du résultat.
return [
{
"type": "image",
"source": {
"type": "base64",
"media_type": "image/png",
"data": PLACEHOLDER_PNG,
},
}
]
def click(coordinate=None):
if coordinate is None:
return "clicked at current cursor"
x, y = coordinate
return f"clicked at ({x}, {y})"
def type_text(text):
return f"typed: {text}"
def handle_computer_action(name, tool_input):
match name:
case "screenshot":
return capture_screenshot()
case "left_click":
# coordinate est facultatif ; sans lui, cliquer là où se trouve déjà le curseur.
return click(tool_input.get("coordinate"))
case "type":
return type_text(tool_input["text"])
# Gérer les autres actions selon les besoins.
raise ValueError(f"Unknown or unimplemented member: {name}")
```
```typescript TypeScript
// Données d'image fictives ; un exécuteur réel capture l'écran en octets PNG
const PLACEHOLDER_PNG =
"iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==";
function captureScreenshot(): Anthropic.ImageBlockParam[] {
// screenshot répond avec un bloc image plutôt que du texte
return [
{
type: "image",
source: {
type: "base64",
media_type: "image/png",
data: PLACEHOLDER_PNG
}
}
];
}
function clickAt(x: number, y: number): string {
return `clicked at (${x}, ${y})`;
}
function clickAtCursor(): string {
return "clicked at the current cursor position";
}
function typeText(text: string): string {
return `typed: ${text}`;
}
function handleComputerAction(
action: string,
input: unknown
): string | Anthropic.ImageBlockParam[] {
const params: object = typeof input === "object" && input !== null ? input : {};
switch (action) {
case "screenshot":
return captureScreenshot();
case "left_click":
// coordinate est facultatif dans l'ensemble d'outils ; sans lui, cliquer à la position du curseur
if ("coordinate" in params && Array.isArray(params.coordinate)) {
const [x, y] = params.coordinate;
return clickAt(x, y);
}
return clickAtCursor();
case "type":
if ("text" in params) {
return typeText(String(params.text));
}
break;
}
// Gérer les autres actions selon les besoins
throw new Error(`Unknown or unimplemented member: ${action}`);
}
```
```csharp C#
// Données d'image fictives ; un exécuteur réel capture l'écran et renvoie les octets PNG
const string PlaceholderPng = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==";
// screenshot répond avec un bloc image plutôt que du texte : renvoyer la liste de contenu du résultat
List CaptureScreenshot() =>
[
new ImageBlockParam(
new Base64ImageSource { Data = PlaceholderPng, MediaType = MediaType.ImagePng }
),
];
string ClickAt(int x, int y) => $"clicked at ({x}, {y})";
string ClickAtCursor() => "clicked at the current cursor position";
string TypeText(string text) => $"typed: {text}";
ToolResultBlockParamContent HandleComputerAction(
string action,
IReadOnlyDictionary input
) =>
action switch
{
"screenshot" => CaptureScreenshot(),
// coordinate est facultatif pour les membres click ; sans lui, cliquer à la position du curseur
"left_click" when input.TryGetValue("coordinate", out var xy) => ClickAt(
xy[0].GetInt32(),
xy[1].GetInt32()
),
"left_click" => ClickAtCursor(),
"type" => TypeText(input["text"].GetString()!),
// Gérer les autres actions selon les besoins
_ => throw new NotSupportedException($"Unknown or unimplemented member: {action}"),
};
```
```go Go
// placeholderPNG remplace une capture réelle : un exécuteur renvoie
// l'écran sous forme de données PNG encodées en base64.
const placeholderPNG = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg=="
// captureScreenshot renvoie un bloc image plutôt que du texte.
func captureScreenshot() []anthropic.ToolResultBlockParamContentUnion {
return []anthropic.ToolResultBlockParamContentUnion{{
OfImage: &anthropic.ImageBlockParam{
Source: anthropic.ImageBlockParamSourceUnion{
OfBase64: &anthropic.Base64ImageSourceParam{
MediaType: anthropic.Base64ImageSourceMediaTypeImagePNG,
Data: placeholderPNG,
},
},
},
}}
}
// textContent encapsule le texte en tant que contenu tool_result.
func textContent(text string) []anthropic.ToolResultBlockParamContentUnion {
return []anthropic.ToolResultBlockParamContentUnion{
{OfText: &anthropic.TextBlockParam{Text: text}},
}
}
func clickAt(x, y int) string {
return fmt.Sprintf("clicked at (%d, %d)", x, y)
}
func clickAtCursor() string {
return "clicked at the current cursor position"
}
func typeText(text string) string {
return fmt.Sprintf("typed: %s", text)
}
func handleComputerAction(action string, params map[string]any) ([]anthropic.ToolResultBlockParamContentUnion, error) {
switch action {
case "screenshot":
return captureScreenshot(), nil
case "left_click":
// coordinate est facultatif ; sans lui, cliquer là où se trouve déjà le curseur
coord, ok := params["coordinate"].([]any)
if !ok {
return textContent(clickAtCursor()), nil
}
if len(coord) == 2 {
x, xok := coord[0].(float64)
y, yok := coord[1].(float64)
if xok && yok {
return textContent(clickAt(int(x), int(y))), nil
}
}
case "type":
if text, ok := params["text"].(string); ok {
return textContent(typeText(text)), nil
}
// Gérer les autres actions selon les besoins
default:
return nil, fmt.Errorf("unknown or unimplemented member: %s", action)
}
// Atteint lorsqu'il manque un champ dans l'entrée d'un membre ou qu'un champ a le mauvais type
return nil, fmt.Errorf("invalid input for %s", action)
}
```
```java Java
/** Placeholder pixels; a real executor captures the screen and base64-encodes the PNG. */
static final String PLACEHOLDER_PNG = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==";
ToolResultBlockParam.Content captureScreenshot() {
ImageBlockParam image = ImageBlockParam.builder()
.source(Base64ImageSource.builder()
.mediaType(Base64ImageSource.MediaType.IMAGE_PNG)
.data(PLACEHOLDER_PNG)
.build())
.build();
return ToolResultBlockParam.Content.ofBlocks(
List.of(ToolResultBlockParam.Content.Block.ofImage(image)));
}
String clickAt(long x, long y) {
return "clicked at (" + x + ", " + y + ")";
}
String clickAtCursor() {
return "clicked at current cursor";
}
String typeText(String text) {
return "typed: " + text;
}
/** Runs one computer toolset member; {@code action} is the tool_use block's name. */
ToolResultBlockParam.Content handleComputerAction(String action, Map input) {
if (action.equals("screenshot")) {
return captureScreenshot(); // the one member here that answers with an image block
}
String output = switch (action) {
case "left_click" -> {
JsonValue coordinate = input.get("coordinate"); // optional on the toolset
if (coordinate == null) {
yield clickAtCursor();
}
List point = (List) coordinate.asArray().get();
long x = ((Number) point.get(0).asNumber().get()).longValue();
long y = ((Number) point.get(1).asNumber().get()).longValue();
yield clickAt(x, y);
}
case "type" -> typeText(input.get("text").asStringOrThrow());
// Gérer les autres actions selon les besoins
default -> throw new UnsupportedOperationException("Unknown or unimplemented member: " + action);
};
return ToolResultBlockParam.Content.ofString(output);
}
```
```php PHP
// Substitut aux vrais octets PNG ; un véritable exécuteur capture l'écran
const PLACEHOLDER_PNG = 'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==';
function captureScreenshot(): array
{
// screenshot répond avec un bloc image plutôt que du texte, donc renvoyer la liste de contenu du résultat
$image = [
'type' => 'image',
'source' => ['type' => 'base64', 'media_type' => 'image/png', 'data' => PLACEHOLDER_PNG],
];
return [$image];
}
function clickAt(?array $coordinate): string
{
// left_click peut omettre coordinate, auquel cas le clic se produit là où se trouve déjà le curseur
if ($coordinate === null) {
return 'clicked at current cursor';
}
[$x, $y] = $coordinate;
return "clicked at ({$x}, {$y})";
}
function typeText(string $text): string
{
return "typed: {$text}";
}
function handleComputerAction(string $name, array $input): string|array
{
return match ($name) {
'screenshot' => captureScreenshot(),
'left_click' => clickAt($input['coordinate'] ?? null),
'type' => typeText($input['text']),
// Gérer les autres actions selon les besoins
default => throw new \RuntimeException("Unknown or unimplemented member: {$name}"),
};
}
```
```ruby Ruby
# Données d'image factices ; un véritable exécuteur capture l'écran au format PNG.
PLACEHOLDER_PNG = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg=="
# screenshot répond avec un bloc image plutôt que du texte
def capture_screenshot
[
{
type: "image",
source: { type: "base64", media_type: "image/png", data: PLACEHOLDER_PNG }
}
]
end
def click(coordinate = nil)
return "clicked at current cursor" if coordinate.nil?
x, y = coordinate
"clicked at (#{x}, #{y})"
end
def type_text(text)
"typed: #{text}"
end
def handle_computer_action(name, input)
case name
when "screenshot"
capture_screenshot
when "left_click"
# coordinate est facultatif ; sans lui, cliquer là où se trouve déjà le curseur
click(input[:coordinate])
when "type"
type_text(input[:text])
# Gérer les autres actions selon les besoins
else
raise ArgumentError, "Unknown or unimplemented member: #{name}"
end
end
```
Extrayez et exécutez les appels d’outils à partir des réponses de Claude :
```python Python
NOT_EXECUTED = "Not executed: an earlier computer action in this turn failed."
def process_tool_calls(response: Message) -> list[ToolResultBlockParam]:
"""
Run the computer actions in Claude's response in order and answer each
one. After the first failure the rest are skipped, because Claude planned
them assuming the earlier actions succeeded.
"""
tool_results: list[ToolResultBlockParam] = []
failed = False
for block in response.content:
# Seul le jeu d'outils computer est déclaré ; routez ici les autres outils si vous en ajoutez.
if block.type != "tool_use" or block.toolset_name != "computer":
continue
result: ToolResultBlockParam = {
"type": "tool_result",
"tool_use_id": block.id,
"toolset_name": "computer",
}
if failed:
result["content"] = NOT_EXECUTED
result["is_error"] = True
else:
try:
# Une chaîne, ou une liste de blocs de contenu tels que l'image de capture d'écran.
result["content"] = handle_computer_action(block.name, block.input)
except Exception as err:
result["content"] = f"Error: {err}"
result["is_error"] = True
failed = True
tool_results.append(result)
return tool_results
```
```typescript TypeScript
const HALT_TEXT = "Not executed: an earlier computer action in this turn failed.";
function computerResult(
toolUseId: string,
content: string | Anthropic.ImageBlockParam[],
isError?: boolean
): Anthropic.ToolResultBlockParam {
return {
type: "tool_result",
tool_use_id: toolUseId,
toolset_name: "computer",
content,
is_error: isError
};
}
function processToolCalls(response: Anthropic.Message): Anthropic.ToolResultBlockParam[] {
const toolResults: Anthropic.ToolResultBlockParam[] = [];
let failed = false;
for (const block of response.content) {
if (block.type !== "tool_use") {
continue;
}
if (block.toolset_name !== "computer") {
// Cet exemple ne déclare que le jeu d'outils computer ; routez les autres outils
// ici si vous en ajoutez.
continue;
}
if (failed) {
// Un lot s'arrête au premier échec ; répondre aux actions suivantes sans les exécuter.
toolResults.push(computerResult(block.id, HALT_TEXT, true));
continue;
}
try {
// Une chaîne, ou la liste de blocs image que renvoie screenshot
const result = handleComputerAction(block.name, block.input);
toolResults.push(computerResult(block.id, result));
} catch (error) {
failed = true;
const message = error instanceof Error ? error.message : String(error);
toolResults.push(computerResult(block.id, `Error: ${message}`, true));
}
}
return toolResults;
}
```
```csharp C#
const string HaltText = "Not executed: an earlier computer action in this turn failed.";
List ProcessToolCalls(Message response)
{
List toolResults = [];
var failed = false;
foreach (var block in response.Content)
{
if (!block.TryPickToolUse(out var toolUse))
{
continue;
}
if (toolUse.ToolsetName != "computer")
{
// Cet exemple ne déclare que le jeu d'outils computer ; routez les autres outils
// ici si vous en ajoutez.
continue;
}
if (failed)
{
// Un lot s'arrête à son premier échec ; répondre aux actions suivantes sans les exécuter
toolResults.Add(
new ToolResultBlockParam(toolUse.ID)
{
Content = HaltText,
IsError = true,
ToolsetName = "computer",
}
);
continue;
}
try
{
// Une chaîne, ou la liste de blocs image que renvoie screenshot
var result = HandleComputerAction(toolUse.Name, toolUse.Input);
toolResults.Add(
new ToolResultBlockParam(toolUse.ID) { Content = result, ToolsetName = "computer" }
);
}
catch (Exception e)
{
failed = true;
toolResults.Add(
new ToolResultBlockParam(toolUse.ID)
{
Content = $"Error: {e.Message}",
IsError = true,
ToolsetName = "computer",
}
);
}
}
return toolResults;
}
```
```go Go
const notExecuted = "Not executed: an earlier computer action in this turn failed."
// computerToolResult construit le résultat d'une action computer. Contrairement à un
// résultat d'outil ordinaire, il doit reprendre le nom du toolset.
func computerToolResult(toolUseID string, content []anthropic.ToolResultBlockParamContentUnion, isError bool) anthropic.ContentBlockParamUnion {
result := anthropic.ToolResultBlockParam{
ToolUseID: toolUseID,
ToolsetName: anthropic.String("computer"),
Content: content,
}
if isError {
result.IsError = anthropic.Bool(true)
}
return anthropic.ContentBlockParamUnion{OfToolResult: &result}
}
// processToolCalls exécute dans l'ordre les actions computer de la réponse de Claude et
// construit un tool_result pour chaque bloc tool_use. Après le premier échec, il ignore
// les suivantes : Claude les a planifiées en supposant que les actions précédentes avaient réussi.
func processToolCalls(response *anthropic.Message) []anthropic.ContentBlockParamUnion {
var toolResults []anthropic.ContentBlockParamUnion
failed := false
for _, block := range response.Content {
switch variant := block.AsAny().(type) {
case anthropic.ToolUseBlock:
// Cet exemple ne déclare que le toolset computer ; routez ici les autres outils si vous en ajoutez.
if variant.ToolsetName != "computer" {
continue
}
if failed {
toolResults = append(toolResults, computerToolResult(variant.ID, textContent(notExecuted), true))
continue
}
var input map[string]any
var content []anthropic.ToolResultBlockParamContentUnion
err := json.Unmarshal(variant.Input, &input)
if err == nil {
// Du texte, ou le bloc image que renvoie screenshot
content, err = handleComputerAction(variant.Name, input)
}
if err != nil {
failed = true
content = textContent("Error: " + err.Error())
}
toolResults = append(toolResults, computerToolResult(variant.ID, content, err != nil))
}
}
return toolResults
}
```
```java Java
/** The exact text the toolset contract prescribes for member calls skipped after a failure. */
static final String HALT_TEXT = "Not executed: an earlier computer action in this turn failed.";
/** Every result answering a computer toolset member echoes toolset_name. */
ToolResultBlockParam.Builder computerResult(ToolUseBlock toolUse) {
return ToolResultBlockParam.builder()
.toolUseId(toolUse.id())
.toolsetName("computer");
}
/**
* Run the computer actions in Claude's response in order and build one
* tool_result for each tool_use block. After the first failure, skip the rest:
* Claude planned them assuming the earlier actions succeeded.
*/
List processToolCalls(Message response) {
List toolResults = new ArrayList<>();
boolean failed = false;
for (ContentBlock block : response.content()) {
// Cet exemple ne déclare que le jeu d'outils computer ; routez ici les autres outils si vous en ajoutez.
if (!block.isToolUse() || !block.asToolUse().toolsetName().equals(Optional.of("computer"))) {
continue;
}
ToolUseBlock toolUse = block.asToolUse();
ToolResultBlockParam result;
if (failed) {
result = computerResult(toolUse)
.content(HALT_TEXT)
.isError(true)
.build();
} else {
try {
Map input =
(Map) toolUse._input().asObject().get();
// Une chaîne, ou le bloc image renvoyé par screenshot
ToolResultBlockParam.Content output = handleComputerAction(toolUse.name(), input);
result = computerResult(toolUse)
.content(output)
.build();
} catch (RuntimeException e) {
failed = true;
result = computerResult(toolUse)
.content("Error: " + e.getMessage())
.isError(true)
.build();
}
}
toolResults.add(ContentBlockParam.ofToolResult(result));
}
return toolResults;
}
```
```php PHP
const HALT_TEXT = 'Not executed: an earlier computer action in this turn failed.';
function processToolCalls(Message $response): array
{
$toolResults = [];
$failed = false;
foreach ($response->content as $block) {
// Cet exemple ne déclare que le jeu d'outils computer ; routez ici les autres outils si vous en ajoutez.
if (!($block instanceof \Anthropic\Messages\ToolUseBlock) || $block->toolsetName !== 'computer') {
continue;
}
$result = ['type' => 'tool_result', 'tool_use_id' => $block->id, 'toolset_name' => 'computer'];
if ($failed) {
// Un lot s'arrête à son premier échec ; les actions restantes reçoivent une réponse sans être exécutées
$toolResults[] = [...$result, 'content' => HALT_TEXT, 'is_error' => true];
continue;
}
try {
// Une chaîne, ou la liste de blocs image que renvoie screenshot
$toolResults[] = [...$result, 'content' => handleComputerAction($block->name, $block->input)];
} catch (\Throwable $e) {
$failed = true;
$toolResults[] = [...$result, 'content' => 'Error: ' . $e->getMessage(), 'is_error' => true];
}
}
return $toolResults;
}
```
```ruby Ruby
NOT_EXECUTED = "Not executed: an earlier computer action in this turn failed."
# Exécuter dans l'ordre les actions computer de la réponse de Claude et créer un
# tool_result pour chaque bloc tool_use. Après le premier échec, ignorer le reste :
# Claude les a planifiées en supposant que les actions précédentes avaient réussi.
def process_tool_calls(response)
tool_results = []
failed = false
response.content.each do |block|
# Cet exemple ne déclare que le jeu d'outils computer ; routez ici les autres outils
# si vous en ajoutez.
next unless block.type == :tool_use && block.toolset_name == "computer"
result = { type: "tool_result", tool_use_id: block.id, toolset_name: "computer" }
if failed
result.update(content: NOT_EXECUTED, is_error: true)
else
begin
# Une String, ou les blocs de contenu image que renvoie screenshot
result[:content] = handle_computer_action(block.name, block.input)
rescue => e
result.update(content: "Error: #{e.message}", is_error: true)
failed = true
end
end
tool_results << result
end
tool_results
end
```
Enveloppez les deux étapes précédentes dans une boucle qui renvoie les résultats et se répète jusqu’à ce que Claude ne renvoie plus d’appels d’outils membres ; [Comprendre la boucle d’agent](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/computer-use-tool#understanding-the-agentic-loop) présente cette boucle.
### Gérer les erreurs
Signalez une action échouée à Claude sous la forme d’un `tool_result` avec `is_error: true` et une courte description, et incluez `"toolset_name": "computer"` comme pour tout autre résultat de membre. Si l’action échouée faisait partie d’une [action groupée](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/computer-use-tool#batch-actions), répondez aux blocs restants du lot avec le texte d’arrêt indiqué dans cette section au lieu de les exécuter.
Par exemple, lorsque la capture d’écran échoue :
```json
{
"role": "user",
"content": [
{
"type": "tool_result",
"tool_use_id": "toolu_01A09q90qw90lq917835lq9",
"toolset_name": "computer",
"content": "Error: Failed to capture screenshot. Display may be locked or unavailable.",
"is_error": true
}
]
}
```
Utilisez la même forme pour les coordonnées situées en dehors des limites de l’affichage et pour les actions qui ne parviennent pas à s’exécuter, avec un message indiquant ce qui s’est mal passé.
### Dimensionner les captures d’écran pour respecter les limites d’image
Les captures d’écran et les images de zoom que vous renvoyez à l’ensemble d’outils d’utilisation de l’ordinateur doivent déjà respecter les [limites de taille d’image](https://platform.claude.com/docs/fr/build-with-claude/vision#evaluate-image-size) de votre modèle : l’ensemble d’outils ne prend aucune dimension d’affichage et l’API ne réduit pas la taille à votre place, de sorte qu’une image `tool_result` surdimensionnée est rejetée avec une erreur de validation. Comme Claude renvoie des coordonnées dans l’espace de pixels de l’image qu’il reçoit, conservez le facteur d’échelle que vous avez utilisé afin de pouvoir reconvertir ces coordonnées vers votre écran.
Les limites varient selon le modèle. Claude Opus 4.7 et les modèles ultérieurs, y compris tous les modèles qui prennent en charge `computer_toolset_20260801`, acceptent jusqu’à 2 576 pixels sur le bord le plus long et 4 784 tokens visuels au total (`⌈width / 28⌉ × ⌈height / 28⌉`, soit environ 3,75 mégapixels) ; les modèles antérieurs acceptent jusqu’à 1 568 pixels sur le bord le plus long et environ 1,15 mégapixel au total (consultez [Résolution et coût en tokens](https://platform.claude.com/docs/fr/build-with-claude/vision#evaluate-image-size) pour connaître le niveau de chaque modèle). L’exemple suivant utilise les limites de 1 568 px / 1,15 MP des modèles antérieurs. Pour un modèle du niveau haute résolution, dimensionnez en fonction de la limite de tokens visuels plutôt que d’un total de pixels, par exemple avec la fonction utilitaire de redimensionnement présentée dans [Redimensionner votre image avant le téléversement](https://platform.claude.com/docs/fr/build-with-claude/vision-coordinates#resize-your-image-before-uploading).
Si votre écran dépasse la limite, redimensionnez chaque capture d’écran avant de la renvoyer et remettez à l’échelle les coordonnées renvoyées par Claude vers l’espace de l’écran d’origine. Comme l’ensemble d’outils ne prend aucune dimension d’affichage, le redimensionnement et la mise à l’échelle des coordonnées dans le code de votre application suffisent :
```python Python
import math
screen_width, screen_height = 1512, 982
def get_scale_factor(width, height):
"""Calculate scale factor to meet API constraints."""
long_edge = max(width, height)
total_pixels = width * height
long_edge_scale = 1568 / long_edge
total_pixels_scale = math.sqrt(1_150_000 / total_pixels)
return min(1.0, long_edge_scale, total_pixels_scale)
# Lors de la capture d'écran
scale = get_scale_factor(screen_width, screen_height)
scaled_width = int(screen_width * scale)
scaled_height = int(screen_height * scale)
# Redimensionner l'image aux dimensions mises à l'échelle avant de l'envoyer à Claude
screenshot = capture_and_resize(scaled_width, scaled_height)
# Lors du traitement des coordonnées de Claude, les remettre à l'échelle d'origine
def execute_click(x, y):
screen_x = x / scale
screen_y = y / scale
perform_click(screen_x, screen_y)
```
```typescript TypeScript
const screenWidth = 1512;
const screenHeight = 982;
const MAX_LONG_EDGE = 1568;
const MAX_PIXELS = 1_150_000;
function getScaleFactor(width: number, height: number): number {
const longEdge = Math.max(width, height);
const totalPixels = width * height;
const longEdgeScale = MAX_LONG_EDGE / longEdge;
const totalPixelsScale = Math.sqrt(MAX_PIXELS / totalPixels);
return Math.min(1.0, longEdgeScale, totalPixelsScale);
}
// Lors de la capture d'écran
const scale = getScaleFactor(screenWidth, screenHeight);
const scaledWidth = Math.floor(screenWidth * scale);
const scaledHeight = Math.floor(screenHeight * scale);
// Redimensionner l'image aux dimensions mises à l'échelle avant de l'envoyer à Claude
const screenshot = captureAndResize(scaledWidth, scaledHeight);
// Lors du traitement des coordonnées de Claude, les remettre à l'échelle d'origine
function executeClick(x: number, y: number): void {
const screenX = x / scale;
const screenY = y / scale;
performClick(screenX, screenY);
}
```
```csharp C#
int screenWidth = 1512, screenHeight = 982;
double GetScaleFactor(int width, int height)
{
// Calculer le facteur d'échelle pour respecter les contraintes de l'API.
int longEdge = Math.Max(width, height);
int totalPixels = width * height;
double longEdgeScale = 1568.0 / longEdge;
double totalPixelsScale = Math.Sqrt(1_150_000.0 / totalPixels);
return Math.Min(1.0, Math.Min(longEdgeScale, totalPixelsScale));
}
// Lors de la capture d'écran
double scale = GetScaleFactor(screenWidth, screenHeight);
int scaledWidth = (int)(screenWidth * scale);
int scaledHeight = (int)(screenHeight * scale);
// Redimensionner l'image aux dimensions mises à l'échelle avant l'envoi à Claude
var screenshot = CaptureAndResize(scaledWidth, scaledHeight);
// Lors du traitement des coordonnées de Claude, les remettre à l'échelle d'origine
void ExecuteClick(int x, int y)
{
double screenX = x / scale;
double screenY = y / scale;
PerformClick(screenX, screenY);
}
```
```go Go
func getScaleFactor(width, height int) float64 {
longest := float64(max(width, height))
area := float64(width * height)
return min(1.0, 1568/longest, math.Sqrt(1_150_000/area))
}
// ...
screenWidth, screenHeight := 1512, 982
// Lors de la capture d'écran
scale := getScaleFactor(screenWidth, screenHeight)
scaledWidth := int(float64(screenWidth) * scale)
scaledHeight := int(float64(screenHeight) * scale)
// Redimensionner l'image aux dimensions mises à l'échelle avant de l'envoyer à Claude
screenshot := captureAndResize(scaledWidth, scaledHeight)
// Lors du traitement des coordonnées de Claude, les remettre à l'échelle d'origine
executeClick := func(x, y int) {
performClick(float64(x)/scale, float64(y)/scale)
}
```
```java Java
static double getScaleFactor(int width, int height) {
return Math.min(
1.0,
Math.min(
1568.0 / Math.max(width, height),
Math.sqrt(1_150_000.0 / (width * height))
)
);
}
void main() {
int screenWidth = 1512, screenHeight = 982;
// Lors de la capture d'écran
double scale = getScaleFactor(screenWidth, screenHeight);
int scaledWidth = (int)(screenWidth * scale);
int scaledHeight = (int)(screenHeight * scale);
// Redimensionner l'image aux dimensions mises à l'échelle avant de l'envoyer à Claude
var screenshot = captureAndResize(scaledWidth, scaledHeight);
// Lors du traitement des coordonnées de Claude, les remettre à l'échelle d'origine
BiConsumer executeClick =
(x, y) -> performClick(x / scale, y / scale);
// ...
}
```
```php PHP
function getScaleFactor(int $width, int $height): float
{
return min(
1.0,
1568 / max($width, $height),
sqrt(1_150_000 / ($width * $height)),
);
}
$screenWidth = 1512;
$screenHeight = 982;
// Lors de la capture d'écran
$scale = getScaleFactor($screenWidth, $screenHeight);
$scaledWidth = (int)($screenWidth * $scale);
$scaledHeight = (int)($screenHeight * $scale);
// Redimensionner l'image aux dimensions mises à l'échelle avant de l'envoyer à Claude
$screenshot = captureAndResize($scaledWidth, $scaledHeight);
// Lors du traitement des coordonnées de Claude, les remettre à l'échelle d'origine
$executeClick = fn(int $x, int $y) => performClick($x / $scale, $y / $scale);
```
```ruby Ruby
def get_scale_factor(width, height)
[1.0, 1568.0 / [width, height].max, Math.sqrt(1_150_000.0 / (width * height))].min
end
screen_width, screen_height = 1512, 982
# Lors de la capture d'écran
scale = get_scale_factor(screen_width, screen_height)
scaled_width = (screen_width * scale).to_i
scaled_height = (screen_height * scale).to_i
# Redimensionnez l'image aux dimensions mises à l'échelle avant de l'envoyer à Claude.
screenshot = capture_and_resize(scaled_width, scaled_height)
# Lors du traitement des coordonnées de Claude, remettez-les à l'échelle d'origine.
execute_click = ->(x, y) { perform_click(x / scale, y / scale) }
```
**Les écrans Retina de macOS** capturent les captures d’écran avec un rapport de pixels de l’appareil de 2, de sorte que l’image a une résolution deux fois supérieure à celle des coordonnées logiques de l’écran. Réduisez la capture d’écran d’un facteur 2 avant de l’envoyer, ou divisez par deux les coordonnées renvoyées par Claude avant d’effectuer le clic.
Lorsque vous choisissez une résolution d’affichage et renvoyez des captures d’écran :
* Pour les tâches de bureau générales, utilisez 1024x768 ou 1280x720 ; pour les applications web, utilisez 1280x800 ou 1366x768.
* Évitez les résolutions supérieures à 1920x1080 pour prévenir les problèmes de performance.
* Encodez les captures d’écran en PNG ou JPEG base64, et envisagez de compresser les captures d’écran volumineuses pour améliorer les performances.
* Incluez les métadonnées pertinentes telles que l’horodatage ou l’état de l’affichage.
* Si vous utilisez des résolutions plus élevées, assurez-vous que les coordonnées sont mises à l’échelle avec précision.
### Gérer l’historique des captures d’écran
Les longues boucles d’agent accumulent rapidement les captures d’écran (environ 1 000 à 1 800 tokens d’entrée chacune). Les [limites de requête](https://platform.claude.com/docs/fr/build-with-claude/vision#request-limits) de l’API s’appliquent également. Dès qu’une seule requête contient plus de 20 images, chaque image qu’elle contient est soumise à une limite plus stricte par côté. Une boucle qui conserve son historique de captures d’écran atteint ce nombre en quelques dizaines de tours ; redimensionnez donc chaque capture d’écran pour rester sous cette limite, ou supprimez les captures d’écran plus anciennes pour en conserver 20 ou moins dans la requête.
Pour que la « [prompt caching](https://platform.claude.com/docs/fr/build-with-claude/prompt-caching) » (mise en cache des prompts) reste efficace tout en limitant le contexte :
* Placez un point d’arrêt `cache_control` après l’invite système et les définitions d’outils, et jusqu’à trois autres sur le dernier bloc `tool_result` de chacun des tours les plus récents, en les faisant avancer à chaque tour. Au sein d’une [action groupée](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/computer-use-tool#batch-actions), les marqueurs placés sur plusieurs blocs agissent comme un seul point d’arrêt, mais chacun compte tout de même dans la limite de quatre ; n’en utilisez donc qu’un seul au maximum par tour.
* Supprimez les anciennes captures d’écran *par lots*, et non une à chaque tour. Supprimer une capture d’écran à chaque tour modifie le préfixe à chaque tour et invalide le cache. Une valeur par défaut raisonnable consiste à conserver les trois dernières captures d’écran et à effectuer la suppression tous les 25 tours, afin que le préfixe reste identique octet par octet entre deux suppressions ; si vos captures d’écran dépassent la limite plus stricte, choisissez un intervalle qui maintient chaque requête à 20 images ou moins.
* Sur Claude Fable 5.2, Claude Mythos 5.2, Claude Fable 5.1, Claude Mythos 5.1, Claude Opus 5.5, Claude Sonnet 5.5 et Claude Haiku 5.5, évitez d’élaguer côté client : retirer une capture d’écran antérieure d’une requête [invalide tous les blocs de réflexion ultérieurs](https://platform.claude.com/docs/fr/build-with-claude/thinking#preserved-in-conversation) dans cette requête et dans toutes les requêtes suivantes. Redimensionnez plutôt les captures d’écran pour rester sous la limite plus stricte et utilisez l’[effacement des résultats d’outils](https://platform.claude.com/docs/fr/build-with-claude/context-editing#tool-result-clearing) côté serveur pour retirer les anciennes du contexte. Si vous devez élaguer, conservez [`prefix_mismatch_behavior: "drop_block"`](https://platform.claude.com/docs/fr/build-with-claude/thinking#preserved-thinking-controls) défini à partir de ce moment ; après chaque élagage, Claude continue sans la réflexion produite depuis la capture d’écran élaguée, sur cette requête et sur toutes les suivantes. Sur Claude Sonnet 5.5 et Claude Haiku 5.5, `block_binding` fonctionne uniquement avec `thinking: {"type": "adaptive"}`. Avec tout autre paramètre de réflexion sur ces modèles, conservez un historique en ajout seul ou supprimez tous les blocs `thinking` et `redacted_thinking` situés après la capture d’écran élaguée.
### Diagnostiquer les problèmes de clic
Si les clics manquent leurs cibles, la cause est généralement l’une des suivantes :
| Symptôme | Cause probable | Essayez |
| ---------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Les clics sont systématiquement décalés dans une direction | Les coordonnées de Claude, exprimées dans l’espace de pixels des captures d’écran que vous renvoyez, sont appliquées à un affichage de taille différente sans mise à l’échelle | Mettez à l’échelle chaque coordonnée selon le rapport entre la taille de votre écran et celle de votre capture d’écran avant de cliquer (consultez [Dimensionner les captures d’écran pour respecter les limites d’image](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/computer-use-tool#handle-coordinate-scaling-for-higher-resolutions)) ; sur les écrans Retina de macOS, tenez compte du rapport de pixels de l’appareil de 2x |
| Les clics atterrissent dans la bonne zone mais manquent la cible | La cible est très petite, des détails ont été perdus lors de la réduction d’une source 4K+, ou le rapport d’aspect a été déformé | Conservez le membre `zoom` activé et implémentez-le afin que Claude puisse inspecter la région en pleine résolution ; effectuez la capture avec un DPI plus faible ou recadrez sur la région pertinente ; préservez le rapport d’aspect lors du redimensionnement |
| Claude clique sur un élément complètement différent | Instruction ambiguë, ou éléments visuellement similaires à proximité | Utilisez des prompts positionnels (« le bouton bleu Submit en bas à droite ») ; décomposez l’interaction en étapes plus petites |
| La précision est systématiquement médiocre | Résolution trop faible | Essayez 1280x720 comme référence |
**Le choix du modèle influe sur la précision des clics.** Parmi les modèles qui utilisent l’outil `computer_20251124`, Claude Sonnet 4.6 est mécaniquement plus précis lors des clics que Claude Opus 4.6 et est plus robuste lorsque les captures d’écran nécessitent une forte réduction de taille. Claude Opus 4.7 réduit cet écart : sa précision de clic est à peu près comparable à celle de Sonnet 4.6, et sa limite de résolution plus élevée signifie qu’une réduction de taille moindre est nécessaire.
### Suivre les bonnes pratiques d’implémentation
Certaines applications ont besoin de temps pour réagir aux actions :
```python Python
def click_and_wait(x, y, wait_time=0.5):
click_at(x, y)
time.sleep(wait_time) # Allow UI to update
```
```typescript TypeScript
async function clickAndWait(x: number, y: number, waitMs = 500): Promise {
clickAt(x, y);
await new Promise((resolve) => setTimeout(resolve, waitMs)); // Allow UI to update
}
```
```csharp C#
static void ClickAndWait(int x, int y, double waitSeconds = 0.5)
{
ClickAt(x, y);
Thread.Sleep(TimeSpan.FromSeconds(waitSeconds)); // Allow UI to update
}
```
```go Go
func clickAndWaitFor(x, y int, wait time.Duration) {
clickAt(x, y)
time.Sleep(wait) // Allow UI to update
}
func clickAndWait(x, y int) {
clickAndWaitFor(x, y, 500*time.Millisecond)
}
```
```java Java
void clickAndWait(int x, int y) throws InterruptedException {
clickAndWait(x, y, 500);
}
void clickAndWait(int x, int y, long waitTimeMillis) throws InterruptedException {
clickAt(x, y);
Thread.sleep(waitTimeMillis); // Allow UI to update
}
```
```php PHP
function clickAndWait(int $x, int $y, float $waitSeconds = 0.5): void
{
clickAt($x, $y);
usleep((int) ($waitSeconds * 1_000_000)); // Allow UI to update
}
```
```ruby Ruby
def click_and_wait(x, y, wait_time: 0.5)
click_at(x, y)
sleep(wait_time) # Allow UI to update
end
```
Vérifiez que les actions demandées sont sûres et valides :
```python Python
display_width, display_height = 1024, 768
def validate_action(action_type, params):
if action_type == "left_click" and "coordinate" in params:
x, y = params["coordinate"]
if not (0 <= x < display_width and 0 <= y < display_height):
return False, "Coordinates out of bounds"
return True, None
```
```typescript TypeScript
const displayWidth = 1024;
const displayHeight = 768;
interface ActionParams {
coordinate?: [number, number];
}
function validateAction(actionType: string, params: ActionParams): [boolean, string | null] {
if (actionType === "left_click" && params.coordinate) {
const [x, y] = params.coordinate;
if (!(x >= 0 && x < displayWidth && y >= 0 && y < displayHeight)) {
return [false, "Coordinates out of bounds"];
}
}
return [true, null];
}
```
```csharp C#
const int DisplayWidth = 1024;
const int DisplayHeight = 768;
// ...
static (bool IsValid, string? Error) ValidateAction(string actionType, IReadOnlyDictionary parameters)
{
if (actionType == "left_click" && parameters.TryGetValue("coordinate", out JsonElement coordinate))
{
int x = coordinate[0].GetInt32();
int y = coordinate[1].GetInt32();
if (x is < 0 or >= DisplayWidth || y is < 0 or >= DisplayHeight)
{
return (false, "Coordinates out of bounds");
}
}
return (true, null);
}
```
```go Go
const (
displayWidth = 1024
displayHeight = 768
)
func validateAction(actionType string, params map[string]any) (bool, string) {
raw, hasCoordinate := params["coordinate"]
if actionType == "left_click" && hasCoordinate {
coord, ok := raw.([]any)
if !ok || len(coord) != 2 {
return false, "Invalid coordinate"
}
x, y := int(coord[0].(float64)), int(coord[1].(float64))
if !(0 <= x && x < displayWidth && 0 <= y && y < displayHeight) {
return false, "Coordinates out of bounds"
}
}
return true, ""
}
```
```java Java
static final int DISPLAY_WIDTH = 1024;
static final int DISPLAY_HEIGHT = 768;
record Validation(boolean valid, String error) {}
Validation validateAction(String actionType, Map params) {
if (actionType.equals("left_click") && params.containsKey("coordinate")) {
List coord = (List) params.get("coordinate").asArray().get();
long x = ((Number) coord.get(0).asNumber().get()).longValue();
long y = ((Number) coord.get(1).asNumber().get()).longValue();
if (!(0 <= x && x < DISPLAY_WIDTH && 0 <= y && y < DISPLAY_HEIGHT)) {
return new Validation(false, "Coordinates out of bounds");
}
}
return new Validation(true, null);
}
```
```php PHP
const DISPLAY_WIDTH = 1024;
const DISPLAY_HEIGHT = 768;
/** @return array{bool, ?string} */
function validateAction(string $actionType, array $params): array
{
if ($actionType === 'left_click' && isset($params['coordinate'])) {
[$x, $y] = $params['coordinate'];
if (!(0 <= $x && $x < DISPLAY_WIDTH && 0 <= $y && $y < DISPLAY_HEIGHT)) {
return [false, 'Coordinates out of bounds'];
}
}
return [true, null];
}
```
```ruby Ruby
DISPLAY_WIDTH = 1024
DISPLAY_HEIGHT = 768
def validate_action(action_type, params)
if action_type == "left_click" && params.key?(:coordinate)
x, y = params[:coordinate]
unless (0...DISPLAY_WIDTH).cover?(x) && (0...DISPLAY_HEIGHT).cover?(y)
return [false, "Coordinates out of bounds"]
end
end
[true, nil]
end
```
Conservez un journal de toutes les actions pour le dépannage :
```python Python
import logging
def log_action(action_type, params, result):
logging.info(f"Action: {action_type}, Params: {params}, Result: {result}")
```
```typescript TypeScript
function logAction(actionType: string, params: unknown, result: unknown): void {
console.error(
`Action: ${actionType}, Params: ${JSON.stringify(params)}, Result: ${JSON.stringify(
result
)}`
);
}
```
```csharp C#
static void LogAction(string actionType, object? parameters, object? result)
{
Console.Error.WriteLine($"Action: {actionType}, Params: {parameters}, Result: {result}");
}
```
```go Go
func logAction(actionType string, params map[string]any, result any) {
log.Printf("Action: %s, Params: %v, Result: %v", actionType, params, result)
}
```
```java Java
import static java.lang.System.Logger.Level.INFO;
static final System.Logger LOGGER = System.getLogger("computer-use");
void logAction(String actionType, Object params, Object result) {
LOGGER.log(INFO, "Action: {0}, Params: {1}, Result: {2}", actionType, params, result);
}
```
```php PHP
function logAction(string $actionType, array $params, mixed $result): void
{
error_log(sprintf(
'Action: %s, Params: %s, Result: %s',
$actionType,
json_encode($params),
json_encode($result),
));
}
```
```ruby Ruby
require "logger"
LOGGER = Logger.new($stderr)
def log_action(action_type, params, result)
LOGGER.info("Action: #{action_type}, Params: #{params}, Result: #{result}")
end
```
***
## Migrer depuis `computer_20251124`
Une intégration `computer_20251124` fonctionne sans modification sur les modèles répertoriés pour cette version dans [Versions antérieures de l’outil](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/computer-use-tool#earlier-tool-versions). Mettez à niveau l’intégration avant de la migrer vers un modèle qui n’accepte pas `computer_20251124`, comme un modèle Claude 5.5 sur l’API Claude.
Pour effectuer la mise à niveau, apportez les modifications suivantes ensemble :
1. **Supprimez l’en-tête bêta.** Retirez `anthropic-beta: computer-use-2025-11-24` de vos requêtes. Avec le SDK, supprimez `betas` (csharp, go: `Betas`; java: `.addBeta()`) et appelez l’API Messages via le client standard plutôt que via l’espace de noms bêta.
2. **Modifiez l’entrée `tools`.** Définissez `type` sur `computer_toolset_20260801` et supprimez `name`, `display_width_px`, `display_height_px`, `display_number` et `enable_zoom`. L’ensemble d’outils rejette chacun de ces champs.
3. **Choisissez de conserver ou non le zoom activé.** Le zoom est activé par défaut sur l’ensemble d’outils, alors que `enable_zoom` vaut `false` par défaut. Si votre environnement n’implémente pas le zoom, ajoutez `"configs": {"zoom": {"enabled": false}}` pour conserver le comportement précédent ; sinon, implémentez-le (consultez [Actions disponibles](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/computer-use-tool#available-actions)).
4. **Traitez chaque bloc d’un tour.** Mettez à jour votre boucle d’agent afin qu’elle parcoure chaque bloc `tool_use` d’une réponse plutôt que de lire uniquement le premier, et qu’elle répartisse le traitement selon le `name` du bloc combiné à `toolset_name` plutôt que selon `input.action`. Les entrées des membres ne contiennent plus de champ `action` ; les autres champs sont inchangés.
5. **Exécutez les blocs dans l’ordre et utilisez le texte d’arrêt.** Exécutez les blocs séquentiellement, arrêtez-vous au premier échec, et répondez aux blocs restants avec `Not executed: an earlier computer action in this turn failed.` comme décrit dans [Actions groupées](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/computer-use-tool#batch-actions). Si votre boucle ne peut pas encore exécuter de lots, [Paramètres de l’outil](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/computer-use-tool#tool-parameters) explique comment limiter Claude à une action par tour.
6. **Renvoyez `toolset_name` dans les résultats.** Ajoutez `"toolset_name": "computer"` à chaque `tool_result` qui répond à un appel de membre. Les résultats ne peuvent contenir que du contenu `text` et `image`.
7. **Prenez en charge `repeat` sur `key`.** Le membre `key` accepte un nombre `repeat` facultatif compris entre 1 et 100. Un gestionnaire qui ignore les champs non reconnus n’appuierait sur la touche qu’une seule fois ; faites donc en sorte que votre gestionnaire `key` respecte `repeat`.
8. **Redimensionnez vous-même les captures d’écran.** L’ensemble d’outils rejette une capture d’écran ou une image de zoom qui dépasse les limites d’image du modèle au lieu de la réduire. Redimensionnez l’image avant de la renvoyer et continuez à mettre à l’échelle les coordonnées comme décrit dans [Dimensionner les captures d’écran pour respecter les limites d’image](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/computer-use-tool#handle-coordinate-scaling-for-higher-resolutions).
9. **Supprimez les options non prises en charge.** Déplacez tout `defer_loading` de l’entrée vers `configs`, avec la même valeur sur chaque membre activé. Les autres options non prises en charge sur les entrées d’ensemble d’outils sont répertoriées dans [Ensembles d’outils client](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/tool-reference#client-toolsets).
Voici l’entrée `tools` avant la modification, envoyée avec l’en-tête `anthropic-beta: computer-use-2025-11-24` :
```json
{
"type": "computer_20251124",
"name": "computer",
"display_width_px": 1024,
"display_height_px": 768,
"display_number": 1
}
```
Voici l’entrée `tools` après la modification, envoyée sans en-tête bêta. L’objet `configs` maintient le zoom désactivé pour correspondre à l’entrée précédente, qui ne définit pas `enable_zoom` ; omettez entièrement `configs` pour accepter la valeur par défaut et laisser Claude utiliser le zoom :
```json
{
"type": "computer_toolset_20260801",
"configs": {
"zoom": { "enabled": false }
}
}
```
La paire suivante montre un bloc `tool_use` avant et après la modification. Le nom de l’action passe de `input.action` à `name`, et le bloc reçoit `toolset_name` :
```json
{
"type": "tool_use",
"id": "toolu_01A9r5kQm2LxWc7vT3nZ4bJs",
"name": "computer",
"input": { "action": "left_click", "coordinate": [500, 300] }
}
```
```json
{
"type": "tool_use",
"id": "toolu_01A9r5kQm2LxWc7vT3nZ4bJs",
"name": "left_click",
"toolset_name": "computer",
"input": { "coordinate": [500, 300] }
}
```
## Versions antérieures de l’outil
Deux versions antérieures de l’outil « computer use » (utilisation de l’ordinateur) sont disponibles en bêta. Chacune nécessite son [« beta header » (en-tête bêta)](https://platform.claude.com/docs/fr/api/beta-headers) sur chaque requête, et leurs paramètres sont documentés dans la [référence de l’API Messages bêta](https://platform.claude.com/docs/fr/api/beta/messages/create). Avec le SDK, transmettez l’en-tête via `betas` (csharp, go: `Betas`; java: `.addBeta()`) et utilisez l’espace de noms bêta ; seul l’outil d’utilisation de l’ordinateur a besoin de l’en-tête, pas les outils bash ou éditeur de texte dans la même requête.
| Version de l’outil | En-tête bêta | À utiliser avec | Paramètres |
| ------------------- | ------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------- |
| `computer_20251124` | `computer-use-2025-11-24` | Claude Fable 5.1, Claude Mythos 5.1, Claude Fable 5, Claude Mythos 5, Claude Opus 5, Claude Sonnet 5, Claude Opus 4.8, Claude Opus 4.7, Claude Opus 4.6, Claude Sonnet 4.6 et Claude Opus 4.5 | [Référence de l’API](https://platform.claude.com/docs/fr/api/beta/messages/create) |
| `computer_20250124` | `computer-use-2025-01-24` | Claude Sonnet 4.5 ([déprécié](https://platform.claude.com/docs/fr/about-claude/model-deprecations)), Claude Haiku 4.5, Claude Opus 4.1 ([retiré, sauf sur Claude Models on Google Cloud (Google managed) et Bedrock](https://platform.claude.com/docs/fr/about-claude/model-deprecations)), Claude Sonnet 4 ([retiré, sauf sur Claude Models on Google Cloud (Google managed) et Bedrock](https://platform.claude.com/docs/fr/about-claude/model-deprecations)) et Claude Opus 4 ([retiré, sauf sur Claude Models on Google Cloud (Google managed)](https://platform.claude.com/docs/fr/about-claude/model-deprecations)) | [Référence de l’API](https://platform.claude.com/docs/fr/api/beta/messages/create) |
Sur Amazon Bedrock, Claude Fable 5.2, Claude Mythos 5.2, Claude Opus 5.5, Claude Sonnet 5.5 et Claude Haiku 5.5 acceptent également l’outil `computer_20251124` avec l’en-tête bêta `computer-use-2025-11-24`.
***
## Limitations
1. **Latence :** La latence de l’utilisation de l’ordinateur pour les interactions humain-IA peut être trop lente par rapport aux actions informatiques classiques dirigées par un humain. Concentrez-vous sur les cas d’usage où la vitesse n’est pas critique (par exemple, la collecte d’informations en arrière-plan, les tests logiciels automatisés) dans des environnements de confiance.
2. **Précision et fiabilité de la vision par ordinateur :** Claude peut commettre des erreurs ou halluciner lorsqu’il produit des coordonnées spécifiques en générant des actions. La sortie de [réflexion résumée](https://platform.claude.com/docs/fr/build-with-claude/thinking#summarized-thinking) de Claude peut vous aider à comprendre le raisonnement du modèle et à identifier d’éventuels problèmes ; définissez `display: "summarized"` dans la configuration de réflexion, car les modèles qui prennent en charge l’ensemble d’outils omettent le texte de réflexion par défaut.
3. **Précision et fiabilité de la sélection d’outils :** Claude peut commettre des erreurs ou halluciner lors de la sélection d’outils en générant des actions, ou effectuer des actions inattendues pour résoudre des problèmes. De plus, la fiabilité peut être moindre lors de l’interaction avec des applications de niche ou avec plusieurs applications à la fois. Rédigez soigneusement vos prompts lorsque vous demandez des tâches complexes.
4. **Fiabilité du défilement :** L’action de défilement prend en charge le contrôle de la direction (haut, bas, gauche, droite) et une quantité spécifiée. Dans les applications où le défilement ne prend pas effet, des alternatives au clavier telles que Page Down peuvent aider.
5. **Interaction avec les feuilles de calcul :** Utilisez les actions de contrôle fin de la souris (`left_mouse_down`, `left_mouse_up`) et les combinaisons de touches de modification pour sélectionner des cellules individuelles. Les opérations complexes sur les feuilles de calcul peuvent encore nécessiter plusieurs tentatives.
6. **Création de comptes et génération de contenu sur les plateformes sociales et de communication :** Bien que Claude visite des sites web, sa capacité à créer des comptes, à générer et partager du contenu, ou à se livrer de toute autre manière à l’usurpation d’identité humaine sur les sites et plateformes de réseaux sociaux est limitée.
7. **Vulnérabilités :** Les jailbreaks et l’injection de prompts peuvent affecter l’utilisation de l’ordinateur comme ils peuvent affecter tout système d’IA de pointe, y compris via des instructions intégrées dans des pages web ou des images ; appliquez les précautions décrites dans [Considérations de sécurité](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/computer-use-tool#security-considerations).
8. **Actions inappropriées ou illégales :** Conformément aux Conditions d’utilisation d’Anthropic, vous ne devez pas employer l’utilisation de l’ordinateur pour enfreindre une quelconque loi ou la Politique d’utilisation acceptable.
Examinez et vérifiez toujours attentivement les actions et les journaux d’utilisation de l’ordinateur de Claude. N’utilisez pas Claude pour des tâches exigeant une précision parfaite ou des informations utilisateur sensibles sans supervision humaine.
## Conservation des données
L’utilisation de l’ordinateur est un outil côté client. Toutes les captures d’écran, actions de la souris, saisies au clavier et tous les fichiers impliqués dans une session sont capturés et stockés dans votre environnement, et non par Anthropic. Anthropic traite les images de captures d’écran et les demandes d’action en temps réel dans le cadre de l’appel API. La conservation de ces requêtes API est régie par [API et conservation des données](https://platform.claude.com/docs/fr/manage-claude/api-and-data-retention).
Étant donné que votre application contrôle où et comment les données d’utilisation de l’ordinateur sont stockées, l’utilisation de l’ordinateur est éligible à la ZDR.
## Tarification
L’utilisation de l’ordinateur suit la [tarification standard de l’utilisation d’outils](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/overview#pricing). Lors de l’utilisation de l’outil d’utilisation de l’ordinateur :
**Surcharge liée à la définition de l’ensemble d’outils :** Déclarer `computer_toolset_20260801` avec ses membres par défaut ajoute environ 4 500 tokens d’entrée à une requête (environ 4 590 sur Claude Sonnet 5 et environ 4 520 sur les autres modèles pris en charge), ce qui couvre les définitions des outils membres et l’invite système d’utilisation d’outils. Désactiver `zoom` avec `configs` supprime environ 410 de ces tokens. Le nombre exact pour une requête est indiqué dans le champ `usage` de la réponse, et vous pouvez l’estimer à l’avance avec le [point de terminaison de comptage des tokens](https://platform.claude.com/docs/fr/build-with-claude/token-counting).
**Versions antérieures de l’outil :** Les chiffres suivants s’appliquent aux versions d’outil `computer_20251124` et `computer_20250124`, et non à `computer_toolset_20260801` :
* Surcharge de l’invite système : 466 à 499 tokens ajoutés à l’invite système
* Définition de l’outil : environ 735 tokens d’entrée par définition d’outil (mesuré avec `computer_20250124`)
**Consommation de tokens supplémentaire :**
* Captures d’écran et images de zoom renvoyées dans les résultats d’outils, facturées comme entrée d’image (voir la [tarification de la vision](https://platform.claude.com/docs/fr/build-with-claude/vision#evaluate-image-size))
* Résultats d’exécution des outils renvoyés à Claude
Si vous utilisez également les outils bash ou d’éditeur de texte en parallèle de l’utilisation de l’ordinateur, ces outils ont leurs propres coûts en tokens, tels que documentés dans leurs pages respectives.
## Étapes suivantes
Partez du pilote d’un partenaire, ou écrivez le vôtre en Python ou en TypeScript. Le SDK exécute la boucle et le callback d’approbation que vous transmettez.
Corrigez les erreurs d’utilisation d’outils les plus courantes grâce à des tableaux de diagnostic associant symptômes et solutions.
Démarrez avec l’implémentation complète basée sur Docker.
Connectez Claude à des outils et API externes. Découvrez où les outils s’exécutent, quand Claude les appelle et quel outil convient à votre tâche.
Recommandations issues de benchmarks concernant la résolution, l’effort de réflexion et la gestion du contexte.
Laissez Claude naviguer, lire et interagir avec des pages web dans votre propre environnement de navigateur, pour les tâches qui restent dans le navigateur.
## Disponibilité
Outil d’utilisation de l’ordinateur est disponible ou en bêta sur certains modèles et éligible aux dispositifs suivants : zéro conservation des données et préparation HIPAA.
### 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 |
| ---------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Disponible | Claude API, [Claude Models on Google Cloud (Google managed)](https://platform.claude.com/docs/fr/build-with-claude/claude-models-on-google-cloud/google-managed) | [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 Mythos 5.1](https://platform.claude.com/docs/fr/models/mythos-5-1/overview), [Claude Fable 5](https://platform.claude.com/docs/fr/models/fable-5/overview), [Claude Mythos 5](https://platform.claude.com/docs/fr/models/mythos-5/overview), Claude Mythos Preview, [Claude Opus 5.5](https://platform.claude.com/docs/fr/models/opus-5-5/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 Sonnet 5](https://platform.claude.com/docs/fr/models/sonnet-5/overview), [Claude Haiku 5.5](https://platform.claude.com/docs/fr/models/haiku-5-5/overview), [Claude Opus 4.8](https://platform.claude.com/docs/fr/models/opus-4-8/overview) |
| Disponible | [Claude Platform on AWS](https://platform.claude.com/docs/fr/build-with-claude/claude-platform-on-aws), [Amazon Bedrock](https://platform.claude.com/docs/fr/build-with-claude/claude-in-amazon-bedrock), [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 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 Mythos 5.1](https://platform.claude.com/docs/fr/models/mythos-5-1/overview), [Claude Fable 5](https://platform.claude.com/docs/fr/models/fable-5/overview), [Claude Mythos 5](https://platform.claude.com/docs/fr/models/mythos-5/overview), [Claude Opus 5.5](https://platform.claude.com/docs/fr/models/opus-5-5/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 Sonnet 5](https://platform.claude.com/docs/fr/models/sonnet-5/overview), [Claude Haiku 5.5](https://platform.claude.com/docs/fr/models/haiku-5-5/overview), [Claude Opus 4.8](https://platform.claude.com/docs/fr/models/opus-4-8/overview) |
| Bêta | Claude API, [Claude Platform on AWS](https://platform.claude.com/docs/fr/build-with-claude/claude-platform-on-aws), [Amazon Bedrock](https://platform.claude.com/docs/fr/build-with-claude/claude-in-amazon-bedrock), [Amazon Bedrock (InvokeModel)](https://platform.claude.com/docs/fr/build-with-claude/claude-on-amazon-bedrock-legacy), [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 Haiku 4.5](https://platform.claude.com/docs/fr/models/haiku-4-5/overview), [Claude Opus 4.7](https://platform.claude.com/docs/fr/models/opus-4-7/overview), [Claude Opus 4.6](https://platform.claude.com/docs/fr/models/opus-4-6/overview), [Claude Sonnet 4.6](https://platform.claude.com/docs/fr/models/sonnet-4-6/overview), [Claude Opus 4.5](https://platform.claude.com/docs/fr/models/opus-4-5/overview), [Claude Sonnet 4.5](https://platform.claude.com/docs/fr/models/sonnet-4-5/overview) |
#### [Managed Agents](https://platform.claude.com/docs/fr/managed-agents/overview)
* Disponibilité : Non disponible
### 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.
| En-tête | Modèles |
| ------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `computer-use-2025-11-24` | [Claude Opus 4.7](https://platform.claude.com/docs/fr/models/opus-4-7/overview), [Claude Opus 4.6](https://platform.claude.com/docs/fr/models/opus-4-6/overview), [Claude Sonnet 4.6](https://platform.claude.com/docs/fr/models/sonnet-4-6/overview), [Claude Opus 4.5](https://platform.claude.com/docs/fr/models/opus-4-5/overview) |
| `computer-use-2025-01-24` | [Claude Haiku 4.5](https://platform.claude.com/docs/fr/models/haiku-4-5/overview), [Claude Sonnet 4.5](https://platform.claude.com/docs/fr/models/sonnet-4-5/overview) |
### Traitement des données
[Présentation du traitement des données](https://platform.claude.com/docs/fr/manage-claude/api-and-data-retention#feature-eligibility)
| Élément | Zéro conservation des données | HIPAA |
| ------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------- |
| Statut | Éligible (exclut [Modèles couverts](https://platform.claude.com/docs/fr/manage-claude/api-and-data-retention#model-specific-data-retention-requirements)) | Éligible |
| Détails | Outil côté client dont les captures d’écran et les fichiers sont capturés et stockés dans votre environnement, et non par Anthropic. [En savoir plus](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/computer-use-tool#data-retention) | — |
Points de terminaison concernés :
* `/v1/messages` avec l’ensemble d’outils ou l’outil `computer`