---
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:
status: ga
zdr:
eligibility: eligible
note: Excludes [Covered Models](https://platform.claude.com/docs/en/manage-claude/api-and-data-retention#model-specific-data-retention-requirements).
supportedModels:
- claude-fable-5-1
- claude-mythos-5-1
- claude-fable-5
- claude-mythos-5
- claude-opus-5-5
- claude-opus-5
- claude-sonnet-5-5
- claude-sonnet-5
- claude-opus-4-8
- claude-haiku-5-5
supportedPlatforms:
Claude API: ga
Claude Platform on AWS: beta
Amazon Bedrock: beta
Google Cloud: ga
Microsoft Foundry: beta
details:
- Sur l'API Claude et Google Cloud, les modèles Claude 5.5 et ultérieurs prennent en charge l'utilisation de l'ordinateur uniquement via l'ensemble d'outils `computer_toolset_20260801` et renvoient une erreur pour les versions antérieures de l'outil `computer_20251124` et `computer_20250124`. Pour migrer une intégration existante, 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 [Faire 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.
- Sur Amazon Bedrock, Claude Opus 5.5, Claude Sonnet 5.5 et Claude Haiku 5.5 acceptent la version antérieure de l'outil `computer_20251124`, comme le font Claude Opus 5 et Claude Sonnet 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 antérieure 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).
- Les plateformes autres que l'API Claude et Google Cloud ne proposent actuellement que les [versions antérieures de l'outil en bêta](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 de l'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 « computer use » (utilisation de l'ordinateur), 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 » (ensemble d'outils client) défini par Anthropic, voir [ensembles d'outils client](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/tool-reference#client-toolsets) : 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 par tour (une [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) (« browser use tool ») est mieux adapté : ses outils membres lisent et agissent sur la page elle-même, et il ne nécessite pas un environnement de bureau complet.
L'utilisation de l'ordinateur est disponible sur la Claude API et [Google Cloud](https://platform.claude.com/docs/fr/build-with-claude/claude-on-vertex-ai) sous la forme de l'ensemble d'outils `computer_toolset_20260801` ; consultez [Compatibilité](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/computer-use-tool#compatibility) pour connaître les modèles pris en charge.
Les intégrations `computer_20251124` existantes continuent de fonctionner sur les modèles répertoriés pour cette version sous [Versions antérieures de l'outil](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/computer-use-tool#earlier-tool-versions), et les versions antérieures de l'outil restent disponibles en bêta pour les modèles et plateformes qui ne prennent pas en charge 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 effectuer la mise à niveau, ou [Versions antérieures de l'outil](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/computer-use-tool#earlier-tool-versions) pour les en-têtes bêta.
## 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 de l'interaction avec Internet.
Pour minimiser les risques, envisagez de prendre des précautions telles que :
1. Utiliser une machine virtuelle ou un conteneur dédié avec des privilèges minimaux afin de prévenir 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 de prévenir le vol d'informations.
3. Limiter l'accès à Internet à une liste d'autorisation de domaines afin de réduire l'exposition à des contenus malveillants.
4. Demander à un humain de confirmer les décisions susceptibles d'entraîner 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 suivra des commandes trouvées dans le contenu même lorsqu'elles entrent en conflit avec vos instructions. Par exemple, des instructions présentes sur des pages web ou contenues dans des images peuvent supplanter 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 les outils d'utilisation de l'ordinateur, des classificateurs analyseront automatiquement ce que renvoient les outils, comme les captures d'écran, afin de signaler d'éventuelles injections de prompt. Lorsque ces classificateurs identifient une injection de prompt potentielle, ils orienteront automatiquement le modèle pour qu'il vérifie si l'instruction provient réellement de vous avant d'agir en conséquence.
Cette protection supplémentaire ne sera pas idéale pour tous les cas d'usage (par exemple, les cas d'usage sans humain dans la boucle) ; si vous souhaitez la désactiver, [contactez le support](https://support.claude.com/en/). Les précautions ci-dessus 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'édition 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: 2023-06-01" \
-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 MessageParam
{
Role = Role.User,
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: '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: "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` membres, chacun nommant un outil membre et portant `"toolset_name": "computer"`. Au cours de cette tâche, après que Claude a vu 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` par 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 photo de chat sur mon bureau. »
* Claude évalue si agir sur le bureau peut aider à répondre à la demande 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`, signalant une demande d'utilisation d'outils.
* Parcourez chaque bloc `tool_use` de la réponse, dans l'ordre. Pour chacun, effectuez le dispatch sur le `name` du membre ainsi que sur `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` par bloc `tool_use`, associé par `tool_use_id` et reprenant chacun `"toolset_name": "computer"`. Renvoyez une image pour `screenshot` et `zoom` ; un court texte 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 groupe 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` et vous devez retourner à l'étape 3.
* Sinon, il renvoie une réponse textuelle à l'utilisateur.
La répétition des étapes 3 et 4 sans intervention de l'utilisateur est appelée « agent loop » (boucle d'agent), c'est-à-dire que Claude répond par une demande d'utilisation d'outils et que 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 « batch action » (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) avec une différence : vous exécutez les blocs dans l'ordre plutôt que simultanément.
Une réponse contenant un groupe 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 d'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 groupe dépendent généralement des précédentes : le `type` de cet exemple saisit du texte dans l'élément que le clic précédent a sélectionné. Exécutez les blocs séquentiellement dans l'ordre où ils apparaissent dans `content`, et si l'un échoue, n'exécutez pas les suivants. Chaque bloc `tool_use` nécessite tout de même un `tool_result`, répondez donc au groupe comme suit :
* Pour chaque action qui a réussi, 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 groupe, 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 voit alors quelles actions ont réussi, laquelle a échoué et lesquelles ont été ignorées, puis replanifie à son tour suivant. Une requête qui laisse sans réponse un bloc `tool_use` du groupe est rejetée avec une `invalid_request_error`, de sorte qu'une boucle d'agent qui ne lit que le premier bloc échoue à son appel suivant. Si votre application demande à un humain de confirmer les actions à conséquences importantes, effectuez cette vérification avant l'exécution de chaque bloc, car un groupe peut accomplir une action en plusieurs étapes au sein d'un seul tour.
Claude termine généralement un groupe par `screenshot` afin de pouvoir observer le résultat avant de déterminer la suite. Lorsqu'un groupe ne se termine pas ainsi, votre application peut joindre une capture d'écran sous forme de bloc `image` supplémentaire au dernier résultat du groupe afin que Claude voie 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, dans votre prompt, de terminer chaque groupe par une capture d'écran (consultez [Optimiser les performances du modèle grâce au 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 rend l'interface de bureau que Claude verra via des captures d'écran et contrôlera avec des actions de souris et de clavier.
2. **Environnement de bureau :** une interface légère avec gestionnaire de fenêtres (Mutter) et 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 (tels que 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 les 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/anthropic-quickstarts/tree/main/computer-use-demo) est un exemple fonctionnel complet : un [environnement conteneurisé](https://github.com/anthropics/anthropic-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/anthropic-quickstarts/tree/main/computer-use-demo/computer_use_demo/tools), une [boucle d'agent](https://github.com/anthropics/anthropic-quickstarts/blob/main/computer-use-demo/computer_use_demo/loop.py) qui appelle la Claude API et exécute les outils, ainsi qu'une interface web pour le conteneur, la boucle et les outils.
### 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, 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 déclare uniquement l'ensemble d'outils d'utilisation de l'ordinateur, et la fonction utilitaire de traitement des appels d'outils présentée 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'édition 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 des membres de l'utilisation de l'ordinateur, et la boucle considère un tour sans appel traité comme 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()
{
Role = Role.Assistant,
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() { Role = Role.User, 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(MessageParam.builder()
.role(MessageParam.Role.ASSISTANT)
.contentOfBlockParams(response.content().stream().map(ContentBlock::toParam).toList())
.build());
// 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.builder()
.role(MessageParam.Role.USER)
.contentOfBlockParams(toolResults)
.build());
}
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. Ce garde-fou empêche les boucles infinies potentielles qui pourraient entraîner des coûts d'API inattendus.
### Optimiser les performances du modèle grâce au prompting
1. Spécifiez des tâches simples et bien définies et fournissez des instructions explicites pour chaque étape.
2. Claude suppose parfois le résultat de ses actions sans en vérifier explicitement les effets. Pour éviter cela, vous pouvez demander à Claude : `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 avec des 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 ou interactions d'interface répétables, incluez dans votre prompt des exemples de captures d'écran et d'appels d'outils ayant abouti à des résultats réussis.
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 ``. 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 des identifiants de connexion au modèle.
6. Lors de la construction du tableau `content` d'un tour utilisateur, placez le texte d'instruction *avant* l'image de 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 alors que 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 instructions explicites sur la manière de réussir ces tâches.
Pour les agents qui s'étendent sur plusieurs sessions, exécutez une vérification de bout en bout au début de chaque session, et pas seulement après l'implémentation. Les vérifications basées sur le navigateur détectent les régressions issues des sessions précédentes qu'une revue au niveau du code seule 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 contient uniquement 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 les dimensions habituelles de vos captures d'écran 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 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) : 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` : secondes, jusqu'à 300 | Maintient une touche enfoncée pendant la durée indiquée. |
| `wait` | `duration` : secondes, jusqu'à 300 | Fait 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 les coordonnées de Claude à l'échelle 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 sur la paire (`toolset_name`, `name`).** C'est `toolset_name` qui marque un bloc comme une action sur l'ordinateur : un outil personnalisé dans 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` ne maintient les touches de modification que 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" }
}
```
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 donnant 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'elle partage avec l'ensemble d'outils d'utilisation du navigateur sont répertorié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` (`true` par défaut pour les 17, y compris `zoom`) et `defer_loading` (`false` par défaut, 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 ; entrée uniquement. Un point d'arrêt sur n'importe quel bloc `tool_use` ou `tool_result` d'un groupe prend effet à la fin de ce groupe ; 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` 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 les paramètres suivants issus des versions antérieures de l'outil, 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` : le 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`, le placement de `defer_loading`, `tool_choice`, le streaming et les restrictions d'appelant, 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 antérieur `computer_20251124`, les évaluations internes sur les modèles qui l'utilisent suggèrent les réglages `effort` suivants :
* **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 solide 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'édition 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, et les appels aux membres qui partagent un nom, comme `screenshot` ou `key`, sont distingués par `toolset_name`.
### Créer un environnement d'utilisation de l'ordinateur personnalisé
L'[implémentation de référence](https://github.com/anthropics/anthropic-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. Cependant, vous pouvez créer votre propre environnement d'utilisation de l'ordinateur adapté à vos besoins. Vous aurez besoin :
* D'un environnement virtualisé ou conteneurisé adapté à l'utilisation de l'ordinateur avec Claude
* D'une implémentation des actions de l'outil d'utilisation de l'ordinateur
* D'une boucle d'agent qui interagit avec la Claude API et exécute les résultats `tool_use` à l'aide de vos implémentations d'outils
* D'une API ou d'une interface utilisateur permettant à l'utilisateur de lancer 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 interagira. Cela implique généralement de configurer Xvfb (X Virtual Framebuffer) ou 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 à son premier échec ; répondre aux actions suivantes comme non exécutées
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 par bloc tool_use. Après le premier échec, il ignore
// le reste : 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 per 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 informatiques de la réponse de Claude et construire un
# tool_result par 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
```
Encapsulez 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 dans chaque langage.
### 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 groupe 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 les images pour vous, de sorte qu'une image `tool_result` trop grande est rejetée avec une erreur de validation. Comme Claude renvoie les coordonnées dans l'espace de pixels de l'image qu'il voit, 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'à 2576 pixels sur le bord le plus long et 4784 tokens visuels au total (`⌈width / 28⌉ × ⌈height / 28⌉`, environ 3,75 mégapixels) ; les modèles antérieurs acceptent jusqu'à 1568 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 le niveau de chaque modèle). L'exemple suivant utilise les limites de 1568 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 de la téléverser](https://platform.claude.com/docs/fr/build-with-claude/vision-coordinates#resize-your-image-before-uploading).
Si votre écran est plus grand que la limite, redimensionnez chaque capture d'écran avant de la renvoyer et remettez les coordonnées renvoyées par Claude à l'échelle de l'espace d'é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 sont tout ce dont vous avez besoin :
```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 l'envoi à 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
# 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
execute_click = ->(x, y) { perform_click(x / scale, y / scale) }
```
**Les écrans Retina de macOS** capturent les captures d'écran avec un ratio de pixels de l'appareil de 2, de sorte que l'image a une résolution deux fois supérieure aux 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 performances.
* 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 des 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 par côté plus stricte. Une boucle qui conserve son historique de captures d'écran atteint ce nombre en quelques dizaines de tours ; vous devez donc soit redimensionner chaque capture d'écran de sorte qu'aucun côté ne dépasse 2000 px, soit supprimer les captures d'écran plus anciennes pour en conserver 20 ou moins dans la requête.
Pour que le « prompt caching » ([mise en cache des prompts](https://platform.claude.com/docs/fr/build-with-claude/prompt-caching)) 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. Utilisez donc un seul marqueur par tour.
* Élaguez 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 à élaguer tous les 25 tours, afin que le préfixe reste identique octet par octet entre les élagages. Si vos captures d'écran dépassent 2000 px sur l'un ou l'autre côté, choisissez un intervalle qui maintient chaque requête à 20 images ou moins.
* Sur Claude Fable 5.1, Claude Opus 5.5, Claude Sonnet 5.5 et Claude Haiku 5.5, évitez l'élagage côté client : supprimer une capture d'écran antérieure [invalide tous les blocs de réflexion suivants](https://platform.claude.com/docs/fr/build-with-claude/thinking#preserved-in-conversation) dans chaque requête qui contient encore ces tours. Redimensionnez plutôt les captures d'écran à 2000 px ou moins par côté, 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 supprimer 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 poursuit 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, `block_binding` ne fonctionne qu'avec `thinking: {"type": "adaptive"}`. Avec `between_tools`, conservez un historique en ajout seul, ou supprimez les blocs de réflexion à partir du tour modifié. Sur Claude Haiku 5.5, `block_binding` ne fonctionne qu'avec `thinking: {"type": "adaptive"}` ; avec `thinking: {"type": "disabled"}`, conservez un historique en ajout seul, ou supprimez les blocs de réflexion à partir du tour modifié.
### Diagnostiquer les problèmes de clic
Si les clics manquent leur cible, la cause est généralement l'une des suivantes :
| Symptôme | Cause probable | À essayer |
| ---------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Clics systématiquement décalés dans une direction | Les coordonnées de Claude, qui sont exprimées dans l'espace de pixels des captures d'écran que vous renvoyez, sont appliquées à un écran de taille différente sans mise à l'échelle | Mettez à l'échelle chaque coordonnée selon le rapport entre la taille de votre écran et la taille de votre capture d'écran avant de cliquer (voir [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 ratio 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é | Gardez le membre `zoom` activé et implémentez-le afin que Claude puisse inspecter la région en pleine résolution ; capturez à un DPI inférieur ou recadrez sur la région pertinente ; préservez le rapport d'aspect lors du redimensionnement |
| Claude clique sur un élément totalement 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 mauvaise | Résolution trop faible | Essayez 1280x720 comme base de référence |
**Le choix du modèle influe sur la précision des clics.** Parmi les modèles qui utilisent l'outil antérieur `computer_20251124`, Claude Sonnet 4.6 est mécaniquement plus précis pour cliquer que Claude Opus 4.6 et est plus robuste lorsque les captures d'écran nécessitent une forte réduction. 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 moindre est nécessaire.
### Suivre les bonnes pratiques d'implémentation
Certaines applications ont besoin de temps pour répondre 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 setTimeout(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`
La mise à niveau de `computer_20251124` vers le toolset est facultative : les modèles listés pour `computer_20251124` sous [Versions antérieures de l'outil](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/computer-use-tool#earlier-tool-versions) continuent de l'accepter avec son en-tête bêta, de sorte qu'une intégration existante continue de fonctionner jusqu'à ce que vous la modifiiez. Les modèles Claude 5.5 et ultérieurs font exception sur l'API Claude et Google Cloud : ils n'y acceptent que le toolset. Mettez à niveau une intégration avant de la faire passer à l'un d'eux. Sur Amazon Bedrock, Claude Opus 5.5, Claude Sonnet 5.5 et Claude Haiku 5.5 acceptent `computer_20251124`. 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`. Le toolset rejette chacun de ces champs.
3. **Choisissez de garder ou non le zoom activé.** Le zoom est activé par défaut sur le toolset, 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 (voir [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 pour itérer sur chaque bloc `tool_use` d'une réponse plutôt que de ne lire que le premier, et pour effectuer la répartition en fonction du `name` du bloc conjointement avec `toolset_name` au lieu de `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 par lot](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 compteur `repeat` facultatif de 1 à 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.** Le toolset 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 avant de renvoyer l'image 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 de toolset sont répertoriées sous [Toolsets 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 antérieure, qui ne définit pas `enable_zoom` ; omettez entièrement `configs` pour accepter la valeur par défaut et laisser Claude zoomer :
```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 gagne `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 d'utilisation de l'ordinateur restent disponibles en bêta pour les intégrations existantes, pour les modèles qui ne prennent pas en charge le toolset, et sur les plateformes où le toolset n'est pas actuellement disponible. Chacune nécessite son [en-tête bêta](https://platform.claude.com/docs/fr/api/beta-headers) à 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 d'éditeur de texte de 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 ; sur Amazon Bedrock, également Claude Opus 5.5, Claude Sonnet 5.5 et Claude Haiku 5.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 Bedrock et Google Cloud](https://platform.claude.com/docs/fr/about-claude/model-deprecations)), Claude Sonnet 4 ([retiré, sauf sur Bedrock et Google Cloud](https://platform.claude.com/docs/fr/about-claude/model-deprecations)) et Claude Opus 4 ([retiré, sauf sur Google Cloud](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) |
***
## Limitations
1. **Latence :** La « latency » (latence) actuelle de l'utilisation de l'ordinateur pour les interactions humain-IA peut être trop lente par rapport aux actions informatiques habituelles dirigées par un humain. Concentrez-vous sur les cas d'utilisation 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 les problèmes potentiels ; définissez `display: "summarized"` dans la configuration de la réflexion, car les modèles qui prennent en charge le toolset 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 entreprendre 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 médias 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 par le biais d'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 des lois 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 nécessitant une précision parfaite ou impliquant 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 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 au ZDR. Pour l'éligibilité au ZDR de toutes les fonctionnalités, consultez [API et conservation des données](https://platform.claude.com/docs/fr/manage-claude/api-and-data-retention).
## 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 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 symptôme-correctif.
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 évaluées par des benchmarks pour 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 à l'intérieur du navigateur.