Claude est capable d’interagir avec des outils et des fonctions, vous permettant d’étendre les capacités de Claude pour effectuer une plus grande variété de tâches.
Apprenez tout ce dont vous avez besoin pour maîtriser l’utilisation d’outils avec Claude dans le cadre de nos nouveaux cours ! Veuillez continuer à partager vos idées et suggestions en utilisant ce formulaire.
Voici un exemple de comment fournir des outils à Claude en utilisant l’API Messages : 
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-sonnet-4-5",
    "max_tokens": 1024,
    "tools": [
      {
        "name": "get_weather",
        "description": "Get the current weather in a given location",
        "input_schema": {
          "type": "object",
          "properties": {
            "location": {
              "type": "string",
              "description": "The city and state, e.g. San Francisco, CA"
            }
          },
          "required": ["location"]
        }
      }
    ],
    "messages": [
      {
        "role": "user",
        "content": "What is the weather like in San Francisco?"
      }
    ]
  }'

​
Comment fonctionne l’utilisation d’outils

Claude prend en charge deux types d’outils :
  1. Outils client : Outils qui s’exécutent sur vos systèmes, qui incluent :
  2. Outils serveur : Outils qui s’exécutent sur les serveurs d’Anthropic, comme les outils de recherche web et de récupération web. Ces outils doivent être spécifiés dans la requête API mais ne nécessitent pas d’implémentation de votre part.
Les outils définis par Anthropic utilisent des types versionnés (par exemple, web_search_20250305, text_editor_20250124) pour assurer la compatibilité entre les versions de modèles.

​
Outils client

Intégrez les outils client avec Claude en suivant ces étapes :
1

Fournir à Claude des outils et une invite utilisateur

  • Définissez les outils client avec des noms, descriptions et schémas d’entrée dans votre requête API.
  • Incluez une invite utilisateur qui pourrait nécessiter ces outils, par exemple, “Quel temps fait-il à San Francisco ?”
2

Claude décide d'utiliser un outil

  • Claude évalue si des outils peuvent aider avec la requête de l’utilisateur.
  • Si oui, Claude construit une demande d’utilisation d’outil correctement formatée.
  • Pour les outils client, la réponse API a un stop_reason de tool_use, signalant l’intention de Claude.
3

Exécuter l'outil et retourner les résultats

  • Extraire le nom de l’outil et l’entrée de la demande de Claude
  • Exécuter le code de l’outil sur votre système
  • Retourner les résultats dans un nouveau message user contenant un bloc de contenu tool_result
4

Claude utilise le résultat de l'outil pour formuler une réponse

  • Claude analyse les résultats de l’outil pour élaborer sa réponse finale à l’invite utilisateur originale.
Note : Les étapes 3 et 4 sont optionnelles. Pour certains flux de travail, la demande d’utilisation d’outil de Claude (étape 2) pourrait être tout ce dont vous avez besoin, sans renvoyer les résultats à Claude.

​
Outils serveur

Les outils serveur suivent un flux de travail différent :
1

Fournir à Claude des outils et une invite utilisateur

  • Les outils serveur, comme la recherche web et la récupération web, ont leurs propres paramètres.
  • Incluez une invite utilisateur qui pourrait nécessiter ces outils, par exemple, “Recherchez les dernières nouvelles sur l’IA” ou “Analysez le contenu à cette URL.”
2

Claude exécute l'outil serveur

  • Claude évalue si un outil serveur peut aider avec la requête de l’utilisateur.
  • Si oui, Claude exécute l’outil, et les résultats sont automatiquement incorporés dans la réponse de Claude.
3

Claude utilise le résultat de l'outil serveur pour formuler une réponse

  • Claude analyse les résultats de l’outil serveur pour élaborer sa réponse finale à l’invite utilisateur originale.
  • Aucune interaction utilisateur supplémentaire n’est nécessaire pour l’exécution de l’outil serveur.

​
Exemples d’utilisation d’outils

Voici quelques exemples de code démontrant divers modèles et techniques d’utilisation d’outils. Par souci de brièveté, les outils sont des outils simples, et les descriptions d’outils sont plus courtes que ce qui serait idéal pour assurer les meilleures performances. 
curl https://api.anthropic.com/v1/messages \
     --header "x-api-key: $ANTHROPIC_API_KEY" \
     --header "anthropic-version: 2023-06-01" \
     --header "content-type: application/json" \
     --data \
'{
    "model": "claude-sonnet-4-5",
    "max_tokens": 1024,
    "tools": [{
        "name": "get_weather",
        "description": "Get the current weather in a given location",
        "input_schema": {
            "type": "object",
            "properties": {
                "location": {
                    "type": "string",
                    "description": "The city and state, e.g. San Francisco, CA"
                },
                "unit": {
                    "type": "string",
                    "enum": ["celsius", "fahrenheit"],
                    "description": "The unit of temperature, either \"celsius\" or \"fahrenheit\""
                }
            },
            "required": ["location"]
        }
    }],
    "messages": [{"role": "user", "content": "What is the weather like in San Francisco?"}]
}'
Claude retournera une réponse similaire à :
JSON
{
  "id": "msg_01Aq9w938a90dw8q",
  "model": "claude-sonnet-4-5",
  "stop_reason": "tool_use",
  "role": "assistant",
  "content": [
    {
      "type": "text",
      "text": "I'll check the current weather in San Francisco for you."
    },
    {
      "type": "tool_use",
      "id": "toolu_01A09q90qw90lq917835lq9",
      "name": "get_weather",
      "input": {"location": "San Francisco, CA", "unit": "celsius"}
    }
  ]
}
Vous devriez ensuite exécuter la fonction get_weather avec l’entrée fournie, et retourner le résultat dans un nouveau message user :
curl https://api.anthropic.com/v1/messages \
     --header "x-api-key: $ANTHROPIC_API_KEY" \
     --header "anthropic-version: 2023-06-01" \
     --header "content-type: application/json" \
     --data \
'{
    "model": "claude-sonnet-4-5",
    "max_tokens": 1024,
    "tools": [
        {
            "name": "get_weather",
            "description": "Get the current weather in a given location",
            "input_schema": {
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "The city and state, e.g. San Francisco, CA"
                    },
                    "unit": {
                        "type": "string",
                        "enum": ["celsius", "fahrenheit"],
                        "description": "The unit of temperature, either \"celsius\" or \"fahrenheit\""
                    }
                },
                "required": ["location"]
            }
        }
    ],
    "messages": [
        {
            "role": "user",
            "content": "What is the weather like in San Francisco?"
        },
        {
            "role": "assistant",
            "content": [
                {
                    "type": "text",
                    "text": "I'll check the current weather in San Francisco for you."
                },
                {
                    "type": "tool_use",
                    "id": "toolu_01A09q90qw90lq917835lq9",
                    "name": "get_weather",
                    "input": {
                        "location": "San Francisco, CA",
                        "unit": "celsius"
                    }
                }
            ]
        },
        {
            "role": "user",
            "content": [
                {
                    "type": "tool_result",
                    "tool_use_id": "toolu_01A09q90qw90lq917835lq9",
                    "content": "15 degrees"
                }
            ]
        }
    ]
}'
Cela affichera la réponse finale de Claude, incorporant les données météorologiques :
JSON
{
  "id": "msg_01Aq9w938a90dw8q",
  "model": "claude-sonnet-4-5",
  "stop_reason": "stop_sequence",
  "role": "assistant",
  "content": [
    {
      "type": "text",
      "text": "The current weather in San Francisco is 15 degrees Celsius (59 degrees Fahrenheit). It's a cool day in the city by the bay!"
    }
  ]
}
Claude peut appeler plusieurs outils en parallèle dans une seule réponse, ce qui est utile pour les tâches qui nécessitent plusieurs opérations indépendantes. Lors de l’utilisation d’outils parallèles, tous les bl ocs tool_use sont inclus dans un seul message assistant, et tous les blocs tool_result correspondants doivent être fournis dans le message utilisateur suivant.
Important : Les résultats d’outils doivent être formatés correctement pour éviter les erreurs d’API et s’assurer que Claude continue à utiliser les outils parallèles. Consultez notre guide d’implémentation pour les exigences de formatage détaillées et des exemples de code complets.
Pour des exemples complets, des scripts de test et les meilleures pratiques pour implémenter les appels d’outils parallèles, consultez la section utilisation d’outils en parallèle dans notre guide d’implémentation.
Vous pouvez fournir à Claude plusieurs outils parmi lesquels choisir dans une seule requête. Voici un exemple avec à la fois un outil get_weather et un outil get_time, ainsi qu’une requête utilisateur qui demande les deux.
curl https://api.anthropic.com/v1/messages \
     --header "x-api-key: $ANTHROPIC_API_KEY" \
     --header "anthropic-version: 2023-06-01" \
     --header "content-type: application/json" \
     --data \
'{
    "model": "claude-sonnet-4-5",
    "max_tokens": 1024,
    "tools": [{
        "name": "get_weather",
        "description": "Get the current weather in a given location",
        "input_schema": {
            "type": "object",
            "properties": {
                "location": {
                    "type": "string",
                    "description": "The city and state, e.g. San Francisco, CA"
                },
                "unit": {
                    "type": "string",
                    "enum": ["celsius", "fahrenheit"],
                    "description": "The unit of temperature, either 'celsius' or 'fahrenheit'"
                }
            },
            "required": ["location"]
        }
    },
    {
        "name": "get_time",
        "description": "Get the current time in a given time zone",
        "input_schema": {
            "type": "object",
            "properties": {
                "timezone": {
                    "type": "string",
                    "description": "The IANA time zone name, e.g. America/Los_Angeles"
                }
            },
            "required": ["timezone"]
        }
    }],
    "messages": [{
        "role": "user",
        "content": "What is the weather like right now in New York? Also what time is it there?"
    }]
}'
Dans ce cas, Claude peut soit :
  • Utiliser les outils séquentiellement (un à la fois) — appelant get_weather d’abord, puis get_time après avoir reçu le résultat météorologique
  • Utiliser des appels d’outils parallèles — produisant plusieurs blocs tool_use dans une seule réponse lorsque les opérations sont indépendantes
Lorsque Claude fait des appels d’outils parallèles, vous devez retourner tous les résultats d’outils dans un seul message user, avec chaque résultat dans son propre bloc tool_result.
Si l’invite de l’utilisateur n’inclut pas suffisamment d’informations pour remplir tous les paramètres requis pour un outil, Claude Opus est beaucoup plus susceptible de reconnaître qu’un paramètre manque et de le demander. Claude Sonnet peut demander, surtout lorsqu’il est invité à réfléchir avant de produire une demande d’outil. Mais il peut aussi faire de son mieux pour inférer une valeur raisonnable.Par exemple, en utilisant l’outil get_weather ci-dessus, si vous demandez à Claude “Quel temps fait-il ?” sans spécifier un lieu, Claude, particulièrement Claude Sonnet, peut faire une supposition sur les entrées d’outils :
JSON
{
  "type": "tool_use",
  "id": "toolu_01A09q90qw90lq917835lq9",
  "name": "get_weather",
  "input": {"location": "New York, NY", "unit": "fahrenheit"}
}
Ce comportement n’est pas garanti, surtout pour des invites plus ambiguës et pour des modèles moins intelligents. Si Claude Opus n’a pas suffisamment de contexte pour remplir les paramètres requis, il est beaucoup plus susceptible de répondre avec une question de clarification au lieu de faire un appel d’outil.
Certaines tâches peuvent nécessiter d’appeler plusieurs outils en séquence, en utilisant la sortie d’un outil comme entrée d’un autre. Dans un tel cas, Claude appellera un outil à la fois. S’il est invité à appeler tous les outils en même temps, Claude est susceptible de deviner les paramètres pour les outils plus en aval s’ils dépendent des résultats d’outils pour les outils plus en amont.Voici un exemple d’utilisation d’un outil get_location pour obtenir l’emplacement de l’utilisateur, puis passer cet emplacement à l’outil get_weather :
curl https://api.anthropic.com/v1/messages \
     --header "x-api-key: $ANTHROPIC_API_KEY" \
     --header "anthropic-version: 2023-06-01" \
     --header "content-type: application/json" \
     --data \
'{
    "model": "claude-sonnet-4-5",
    "max_tokens": 1024,
    "tools": [
        {
            "name": "get_location",
            "description": "Get the current user location based on their IP address. This tool has no parameters or arguments.",
            "input_schema": {
                "type": "object",
                "properties": {}
            }
        },
        {
            "name": "get_weather",
            "description": "Get the current weather in a given location",
            "input_schema": {
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "The city and state, e.g. San Francisco, CA"
                    },
                    "unit": {
                        "type": "string",
                        "enum": ["celsius", "fahrenheit"],
                        "description": "The unit of temperature, either 'celsius' or 'fahrenheit'"
                    }
                },
                "required": ["location"]
            }
        }
    ],
    "messages": [{
        "role": "user",
        "content": "What is the weather like where I am?"
    }]
}'
Dans ce cas, Claude appellerait d’abord l’outil get_location pour obtenir l’emplacement de l’utilisateur. Après que vous retourniez l’emplacement dans un tool_result, Claude appellerait ensuite get_weather avec cet emplacement pour obtenir la réponse finale.La conversation complète pourrait ressembler à :
RôleContenu
UtilisateurQuel temps fait-il là où je suis ?
AssistantJe vais d’abord trouver votre emplacement actuel, puis vérifier la météo là-bas. [Utilisation d’outil pour get_location]
Utilisateur[Résultat d’outil pour get_location avec l’id correspondant et le résultat de San Francisco, CA]
Assistant[Utilisation d’outil pour get_weather avec l’entrée suivante]{ “location”: “San Francisco, CA”, “unit”: “fahrenheit” }
Utilisateur[Résultat d’outil pour get_weather avec l’id correspondant et le résultat de “59°F (15°C), principalement nuageux”]
AssistantBasé sur votre emplacement actuel à San Francisco, CA, la météo en ce moment est de 59°F (15°C) et principalement nuageuse. C’est une journée assez fraîche et couverte dans la ville. Vous pourriez vouloir apporter une veste légère si vous sortez.
Cet exemple démontre comment Claude peut enchaîner plusieurs appels d’outils pour répondre à une question qui nécessite de rassembler des données de différentes sources. Les étapes clés sont :
  1. Claude réalise d’abord qu’il a besoin de l’emplacement de l’utilisateur pour répondre à la question météorologique, donc il appelle l’outil get_location.
  2. L’utilisateur (c’est-à-dire le code client) exécute la fonction get_location réelle et retourne le résultat “San Francisco, CA” dans un bloc tool_result.
  3. Avec l’emplacement maintenant connu, Claude procède à l’appel de l’outil get_weather, passant “San Francisco, CA” comme paramètre location (ainsi qu’un paramètre unit deviné, car unit n’est pas un paramètre requis).
  4. L’utilisateur exécute à nouveau la fonction get_weather réelle avec les arguments fournis et retourne les données météorologiques dans un autre bloc tool_result.
  5. Finalement, Claude incorpore les données météorologiques dans une réponse en langage naturel à la question originale.
Par défaut, Claude Opus est invité à réfléchir avant de répondre à une requête d’utilisation d’outil pour mieux déterminer si un outil est nécessaire, quel outil utiliser, et les paramètres appropriés. Claude Sonnet et Claude Haiku sont invités à essayer d’utiliser les outils autant que possible et sont plus susceptibles d’appeler un outil inutile ou d’inférer des paramètres manquants. Pour inviter Sonnet ou Haiku à mieux évaluer la requête utilisateur avant de faire des appels d’outils, l’invite suivante peut être utilisée :Invite de chaîne de penséeRépondez à la demande de l'utilisateur en utilisant les outils pertinents (s'ils sont disponibles). Avant d'appeler un outil, faites une analyse. Premièrement, réfléchissez à lequel des outils fournis est l'outil pertinent pour répondre à la demande de l'utilisateur. Deuxièmement, passez en revue chacun des paramètres requis de l'outil pertinent et déterminez si l'utilisateur a directement fourni ou donné suffisamment d'informations pour inférer une valeur. Lorsque vous décidez si le paramètre peut être inféré, considérez attentivement tout le contexte pour voir s'il supporte une valeur spécifique. Si tous les paramètres requis sont présents ou peuvent être raisonnablement inférés, procédez avec l'appel d'outil. MAIS, si une des valeurs pour un paramètre requis manque, N'invoquez PAS la fonction (même pas avec des valeurs de remplissage pour les paramètres manquants) et à la place, demandez à l'utilisateur de fournir les paramètres manquants. NE demandez PAS plus d'informations sur les paramètres optionnels s'ils ne sont pas fournis.
Vous pouvez utiliser des outils pour faire produire à Claude une sortie JSON qui suit un schéma, même si vous n’avez aucune intention d’exécuter cette sortie à travers un outil ou une fonction.Lors de l’utilisation d’outils de cette manière :
  • Vous voulez généralement fournir un seul outil
  • Vous devriez définir tool_choice (voir Forcer l’utilisation d’outils) pour instruire le modèle d’utiliser explicitement cet outil
  • Rappelez-vous que le modèle passera l’input à l’outil, donc le nom de l’outil et la description devraient être du point de vue du modèle.
Ce qui suit utilise un outil record_summary pour décrire une image suivant un format particulier.
#!/bin/bash
IMAGE_URL="https://upload.wikimedia.org/wikipedia/commons/a/a7/Camponotus_flavomarginatus_ant.jpg"
IMAGE_MEDIA_TYPE="image/jpeg"
IMAGE_BASE64=$(curl "$IMAGE_URL" | base64)

curl https://api.anthropic.com/v1/messages \
     --header "content-type: application/json" \
     --header "x-api-key: $ANTHROPIC_API_KEY" \
     --header "anthropic-version: 2023-06-01" \
     --data \
'{
    "model": "claude-sonnet-4-5",
    "max_tokens": 1024,
    "tools": [{
        "name": "record_summary",
        "description": "Record summary of an image using well-structured JSON.",
        "input_schema": {
            "type": "object",
            "properties": {
                "key_colors": {
                    "type": "array",
                    "items": {
                        "type": "object",
                        "properties": {
"r": { "type": "number", "description": "red value [0.0, 1.0]" },
"g": { "type": "number", "description": "green value [0.0, 1.0]" },
"b": { "type": "number", "description": "blue value [0.0, 1.0]" },
"name": { "type": "string", "description": "Human-readable color name in snake_case, e.g. \"olive_green\" or \"turquoise\"" }
                        },
                        "required": [ "r", "g", "b", "name" ]
                    },
                    "description": "Key colors in the image. Limit to less than four."
                },
                "description": {
                    "type": "string",
                    "description": "Image description. One to two sentences max."
                },
                "estimated_year": {
                    "type": "integer",
                    "description": "Estimated year that the image was taken, if it is a photo. Only set this if the image appears to be non-fictional. Rough estimates are okay!"
                }
            },
            "required": [ "key_colors", "description" ]
        }
    }],
    "tool_choice": {"type": "tool", "name": "record_summary"},
    "messages": [
        {"role": "user", "content": [
            {"type": "image", "source": {
                "type": "base64",
                "media_type": "'$IMAGE_MEDIA_TYPE'",
                "data": "'$IMAGE_BASE64'"
            }},
            {"type": "text", "text": "Describe this image."}
        ]}
    ]
}'

​
Tarification

Tool use requests are priced based on:
  1. The total number of input tokens sent to the model (including in the tools parameter)
  2. The number of output tokens generated
  3. For server-side tools, additional usage-based pricing (e.g., web search charges per search performed)
Client-side tools are priced the same as any other Claude API request, while server-side tools may incur additional charges based on their specific usage. The additional tokens from tool use come from:
  • The tools parameter in API requests (tool names, descriptions, and schemas)
  • tool_use content blocks in API requests and responses
  • tool_result content blocks in API requests
When you use tools, we also automatically include a special system prompt for the model which enables tool use. The number of tool use tokens required for each model are listed below (excluding the additional tokens listed above). Note that the table assumes at least 1 tool is provided. If no tools are provided, then a tool choice of none uses 0 additional system prompt tokens.
ModelTool choiceTool use system prompt token count
Claude Opus 4.1auto, none
any, tool		346 tokens
313 tokens
Claude Opus 4auto, none
any, tool		346 tokens
313 tokens
Claude Sonnet 4.5auto, none
any, tool		346 tokens
313 tokens
Claude Sonnet 4auto, none
any, tool		346 tokens
313 tokens
Claude Sonnet 3.7 (deprecated)auto, none
any, tool		346 tokens
313 tokens
Claude Haiku 4.5auto, none
any, tool		346 tokens
313 tokens
Claude Haiku 3.5auto, none
any, tool		264 tokens
340 tokens
Claude Opus 3 (deprecated)auto, none
any, tool		530 tokens
281 tokens
Claude Sonnet 3auto, none
any, tool		159 tokens
235 tokens
Claude Haiku 3auto, none
any, tool		264 tokens
340 tokens
These token counts are added to your normal input and output tokens to calculate the total cost of a request. Référez-vous à notre tableau de comparaison des modèles pour les prix actuels par modèle. Lorsque vous envoyez une invite d’utilisation d’outil, comme toute autre requête API, la réponse affichera les comptes de jetons d’entrée et de sortie dans le cadre des métriques d’usage rapportées.

​
Prochaines étapes

Explorez notre dépôt d’exemples de code d’utilisation d’outils prêts à implémenter dans nos livres de recettes :

Outil Calculatrice

Apprenez comment intégrer un outil calculatrice simple avec Claude pour des calculs numériques précis.

Agent de Service Client

Construisez un bot de service client réactif qui exploite les outils client pour améliorer le support.

Extracteur JSON

Voyez comment Claude et l’utilisation d’outils peuvent extraire des données structurées à partir de texte non structuré.