Demande et utilisation de l'API Claude Messages

Anthropic Claude est un système de dialogue AI très puissant qui peut générer des réponses fluides et naturelles en quelques secondes simplement en entrant un mot d’invite. L’API Claude Messages est le format API natif officiel d’Anthropic, qui, contrairement au format compatible d’OpenAI (Chat Completion), utilise sa propre structure de requête et de réponse, permettant de mieux exploiter les capacités uniques de Claude, telles que l’entrée de contenu multimodal, l’appel d’outils, la réflexion approfondie (Extended Thinking) et d’autres caractéristiques avancées. Ce document présente principalement le processus d’utilisation de l’API Claude Messages, nous permettant d’utiliser une interface native conforme aux normes d’Anthropic pour appeler les fonctionnalités de dialogue de Claude.

Processus de demande

Pour utiliser l’API Claude Messages, commencez par obtenir votre token API sur le tableau de bord Ace Data Cloud pour le garder en réserve.

Si vous n’êtes pas encore connecté ou inscrit, vous serez automatiquement redirigé vers la page de connexion pour vous inviter à vous inscrire et à vous connecter, après quoi vous serez automatiquement renvoyé à la page actuelle. Un seul token API suffit pour appeler tous les services de la plateforme, sans avoir besoin de demander séparément pour chaque service. La première demande vous donnera un quota gratuit pour une expérience sans frais ; lorsque le quota est insuffisant, vous pouvez recharger le solde général dans le tableau de bord.

📘 Documentation complète : Claude Messages API →

Utilisation de base

Le chemin de requête de l’API Claude Messages est /v1/messages, en accord avec l’API officielle d’Anthropic. Nous devons fournir au moins trois paramètres obligatoires :

model : choisir le modèle Claude à utiliser. Le dernier modèle phare est claude-fable-5-1 (contexte de 1 million de tokens, sortie maximale de 128K tokens) ; l’ancien claude-fable-5 reste compatible.
messages : tableau de messages d’entrée, chaque message contenant role (rôle) et content (contenu), où role prend en charge user et assistant.
max_tokens : nombre maximal de tokens de sortie, utilisé pour limiter la longueur de la réponse unique.

Paramètres optionnels courants :

system : mot d’invite système, utilisé pour définir le comportement et le rôle du modèle.
temperature : aléatoire de génération, entre 0 et 1, plus la valeur est élevée, plus la réponse est dispersée.
stream : utiliser ou non la réponse en continu, en le définissant sur true, vous pouvez obtenir un effet de retour lettre par lettre.
stop_sequences : séquences d’arrêt personnalisées, le modèle s’arrêtera de générer lorsqu’il rencontrera ces textes.
top_p : paramètre d’échantillonnage par noyau, utilisé avec la température pour contrôler l’aléatoire de la génération.
top_k : échantillonnage uniquement parmi les K options les plus probables.
tools : définition des outils, permettant au modèle d’appeler des fonctions externes.
tool_choice : contrôle de la manière dont le modèle utilise les outils fournis.
cache_control : crée automatiquement un point de cache à la dernière section de contenu pouvant être mise en cache de la requête ; peut également être écrit sur des sections de contenu spécifiques.

Exemple cURL

curl -X POST 'https://api.acedata.cloud/v1/messages' \
  -H 'accept: application/json' \
  -H 'authorization: Bearer {token}' \
  -H 'content-type: application/json' \
  -d '{
    "model": "claude-fable-5-1",
    "max_tokens": 1024,
    "messages": [
      {
        "role": "user",
        "content": "Hello, Claude"
      }
    ]
  }'

Exemple Python

import requests

url = "https://api.acedata.cloud/v1/messages"

headers = {
    "accept": "application/json",
    "authorization": "Bearer {token}",
    "content-type": "application/json"
}

payload = {
    "model": "claude-fable-5-1",
    "max_tokens": 1024,
    "messages": [
        {"role": "user", "content": "Hello, Claude"}
    ]
}

response = requests.post(url, json=payload, headers=headers)
print(response.json())

Après l’appel, le résultat retourné est le suivant :

{
  "id": "msg_013Zva2CMHLNnXjNJJKqJ2EF",
  "type": "message",
  "role": "assistant",
  "content": [
    {
      "type": "text",
      "text": "Hi! My name is Claude. How can I help you today?"
    }
  ],
  "model": "claude-opus-4-8",
  "stop_reason": "end_turn",
  "stop_sequence": null,
  "usage": {
    "input_tokens": 12,
    "output_tokens": 15
  }
}

Explication des champs de résultat retournés :

id : identifiant unique de ce message.
type : toujours message.
role : toujours assistant.
content : tableau de contenu de réponse, chaque élément contenant type (comme text) et le contenu correspondant.
model : nom du modèle traitant la requête.
stop_reason : raison de l’arrêt. Les valeurs stables incluent end_turn, max_tokens, stop_sequence, tool_use, pause_turn (peut renvoyer le contenu actuel de l’assistant tel quel pour continuer), refusal et model_context_window_exceeded.
stop_sequence : si l’arrêt est dû à une séquence d’arrêt personnalisée, le texte de la séquence d’arrêt correspondante est affiché.
stop_details : lorsque stop_reason est refusal, cela peut inclure la catégorie de refus et l’explication.
usage : statistiques d’utilisation des tokens. input_tokens est l’entrée non mise en cache ; cache_creation_input_tokens et cache_read_input_tokens sont respectivement l’écriture et la lecture de cache ; output_tokens est le nombre de tokens de sortie. Le tarif de lecture de cache officiel pour Fable 5.1 est de 0,25 $/million de tokens, avec des tarifs d'écriture de cache de 12,50$ et 20 $/million de tokens pour 5 minutes et 1 heure respectivement ; les prix réels de la plateforme sont calculés selon les remises des forfaits. Les réponses non en continu peuvent également inclure le cost enregistré par Ace Data Cloud.

Mot d’invite système

L’API Claude Messages prend en charge la définition du mot d’invite système via le champ system, utilisé pour définir le comportement, le rôle et le contexte du modèle.

Exemple Python

import requests

url = "https://api.acedata.cloud/v1/messages"

headers = {
    "accept": "application/json",
    "authorization": "Bearer {token}",
    "content-type": "application/json"
}

payload = {
    "model": "claude-sonnet-4-20250514",
    "max_tokens": 1024,
    "system": "Vous êtes un assistant de traduction professionnel en chinois, veuillez traduire l'anglais saisi par l'utilisateur en chinois.",
    "messages": [
        {"role": "user", "content": "The quick brown fox jumps over the lazy dog."}
    ]
}

response = requests.post(url, json=payload, headers=headers)
print(response.json())

En définissant le mot d’invite system, vous pouvez contrôler précisément le rôle et le comportement de Claude.

Réponse en continu

Cette interface prend également en charge la réponse en continu, en définissant le paramètre stream sur true, vous pouvez obtenir un effet de retour progressif, très adapté pour afficher lettre par lettre sur une page web.

Exemple Python

import requests

url = "https://api.acedata.cloud/v1/messages"

headers = {
    "accept": "application/json",
    "authorization": "Bearer {token}",
    "content-type": "application/json"
}

payload = {
    "model": "claude-sonnet-4-20250514",
    "max_tokens": 1024,
    "stream": True,
    "messages": [
        {"role": "user", "content": "Bonjour, Claude"}
    ]
}

response = requests.post(url, json=payload, headers=headers, stream=True)
for line in response.iter_lines():
    if line:
        print(line.decode("utf-8"))

La réponse en streaming est renvoyée au format Server-Sent Events (SSE), chaque ligne étant préfixée par event: et data:. Les types d’événements en streaming incluent :

message_start : début du message, contenant les informations de base du message et le nom du modèle.
content_block_start : début du bloc de contenu.
content_block_delta : mise à jour incrémentielle du bloc de contenu, contenant de nouveaux segments de texte générés.
content_block_stop : fin du bloc de contenu.
message_delta : mise à jour incrémentielle au niveau du message, contenant des informations sur stop_reason et l’utilisation finale.
message_stop : fin du message.

Le résultat de sortie est comme suit :

event: message_start
data: {"type":"message_start","message":{"id":"msg_01XFDUDYJgAACzvnptvVoYEL","type":"message","role":"assistant","content":[],"model":"claude-sonnet-4-20250514","stop_reason":null,"stop_sequence":null,"usage":{"input_tokens":12,"output_tokens":0}}}

event: content_block_start
data: {"type":"content_block_start","index":0,"content_block":{"type":"text","text":""}}

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"Salut"}}

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"! Je m'appelle"}}

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":" Claude. Comment puis-je vous aider aujourd'hui?"}}

event: content_block_stop
data: {"type":"content_block_stop","index":0}

event: message_delta
data: {"type":"message_delta","delta":{"stop_reason":"end_turn","stop_sequence":null},"usage":{"output_tokens":15}}

event: message_stop
data: {"type":"message_stop"}

On peut voir que l’événement content_block_delta dans la réponse en streaming contient le contenu textuel généré progressivement, en concaténant tous les text_delta pour obtenir la réponse complète.

Exemple JavaScript

const options = {
  method: "POST",
  headers: {
    accept: "application/json",
    authorization: "Bearer {token}",
    "content-type": "application/json",
  },
  body: JSON.stringify({
    model: "claude-sonnet-4-20250514",
    max_tokens: 1024,
    stream: true,
    messages: [{ role: "user", content: "Bonjour, Claude" }],
  }),
};

const response = await fetch("https://api.acedata.cloud/v1/messages", options);
const reader = response.body.getReader();
const decoder = new TextDecoder();

while (true) {
  const { done, value } = await reader.read();
  if (done) break;
  console.log(decoder.decode(value));
}

Dialogue multi-tours

Si vous souhaitez intégrer une fonctionnalité de dialogue multi-tours, vous devez alterner les messages des rôles user et assistant dans le tableau messages, en incluant l’historique des conversations précédentes.

Exemple Python

import requests

url = "https://api.acedata.cloud/v1/messages"

headers = {
    "accept": "application/json",
    "authorization": "Bearer {token}",
    "content-type": "application/json"
}

payload = {
    "model": "claude-sonnet-4-20250514",
    "max_tokens": 1024,
    "messages": [
        {"role": "user", "content": "Bonjour, je m'appelle Alice."},
        {"role": "assistant", "content": "Bonjour Alice ! Ravi de vous rencontrer. Comment puis-je vous aider aujourd'hui ?"},
        {"role": "user", "content": "Quel est mon nom ?"}
    ]
}

response = requests.post(url, json=payload, headers=headers)
print(response.json())

Le résultat de retour est comme suit :

{
  "id": "msg_01Y1wfQmd89g968TVbFu57Yc",
  "type": "message",
  "role": "assistant",
  "content": [
    {
      "type": "text",
      "text": "Votre nom est Alice, comme vous venez de me le dire !"
    }
  ],
  "model": "claude-sonnet-4-20250514",
  "stop_reason": "end_turn",
  "stop_sequence": null,
  "usage": {
    "input_tokens": 40,
    "output_tokens": 14
  }
}

En passant l’historique complet de la conversation dans messages, Claude peut fournir des réponses précises en tenant compte du contexte.

Modèle de réflexion approfondie

La réflexion de Claude et le résumé de la réflexion sont deux concepts différents : le modèle peut effectuer un raisonnement interne, mais l’API ne renvoie pas la chaîne de pensée brute. Lorsque le processus de raisonnement doit être montré, l’API renvoie un résumé traité. Le modèle actuel recommande d’utiliser la réflexion adaptative et de contrôler l’effort global de raisonnement via output_config.effort :

import requests

url = "https://api.acedata.cloud/v1/messages"
headers = {
    "accept": "application/json",
    "authorization": "Bearer {token}",
    "content-type": "application/json"
}
payload = {
    "model": "claude-opus-5",
    "max_tokens": 16000,
    "thinking": {
        "type": "adaptive",
        "display": "summarized"
    },
    "output_config": {
        "effort": "high"
    },
    "messages": [
        {"role": "user", "content": "Quelle est le sinus de 30 degrés ?"}
    ]
}

response = requests.post(url, json=payload, headers=headers)
print(response.json())

Le bloc de réflexion dans la réponse ressemble à :

{
  "type": "thinking",
  "thinking": "Le problème demande une valeur trigonométrique standard...",
  "signature": "opaque-signature"
}

display: "summarized" renvoie un résumé de réflexion lisible ; ce n’est pas la chaîne de pensée brute.
display: "omitted" renvoie thinking: "", mais conserve toujours la signature opaque pour soutenir les conversations ultérieures.
Les modèles Fable 5.1, Fable 5, Opus 5, Sonnet 5, Opus 4.8 et Opus 4.7 ont par défaut omitted pour l’affichage ; Opus 4.6, Sonnet 4.6 et les modèles plus anciens prenant en charge la réflexion utilisent par défaut summarized.
L’affichage n’affecte que le contenu de retour et le délai de streaming, sans désactiver le raisonnement ni réduire la facturation des tokens de réflexion.
La question de savoir si la réflexion est activée par défaut et la valeur par défaut de l’affichage sont deux questions indépendantes. Opus 5 et Sonnet 5 activent par défaut la réflexion adaptative ; Opus 4.8, 4.7 et 4.6 doivent être explicitement activés.
budget_tokens est uniquement utilisé pour les anciens modèles qui prennent encore en charge un budget de réflexion fixe. Les nouveaux modèles doivent utiliser thinking.type=adaptive et output_config.effort ; la réflexion de Fable 5.1 est toujours activée et ne peut pas être désactivée explicitement.
Lors de dialogues multi-tours et d’appels d’outils, le bloc de réflexion complet et la signature renvoyés par l’assistant doivent être renvoyés tels quels ; ne pas modifier ou générer soi-même la signature.
Certaines routes compatibles ne peuvent pas traiter sans perte redacted_thinking ou désactiver explicitement la réflexion, ce qui renverra une erreur de paramètre sans abandonner silencieusement ou modifier la sémantique de la demande.

Dans les requêtes en streaming, summarized produira thinking_delta ; omitted ne produira pas thinking_delta, mais conservera le cycle de vie du bloc de réflexion et signature_delta.

Modèle visuel

Claude prend en charge les entrées multimodales et peut traiter simultanément du texte et des images. Dans l’API Messages, vous pouvez utiliser les capacités visuelles en définissant content au format tableau et en passant des blocs de contenu d’image.

Utiliser des images encodées en Base64

import base64
import requests

url = "https://api.acedata.cloud/v1/messages"

headers = {
    "accept": "application/json",
    "authorization": "Bearer {token}",
    "content-type": "application/json"
}

# Lire et encoder l'image
with open("image.png", "rb") as f:
    image_data = base64.standard_b64encode(f.read()).decode("utf-8")

payload = {
    "model": "claude-sonnet-4-20250514",
    "max_tokens": 1024,
    "messages": [
        {
            "role": "user",
            "content": [
                {
                    "type": "image",
                    "source": {
                        "type": "base64",
                        "media_type": "image/png",
                        "data": image_data
                    }
                },
                {
                    "type": "text",
                    "text": "Qu'est-ce qu'il y a dans cette image ?"
                }
            ]
        }
    ]
}

response = requests.post(url, json=payload, headers=headers)
print(response.json())

Utiliser des images par URL

import requests

url = "https://api.acedata.cloud/v1/messages"

headers = {
    "accept": "application/json",
    "authorization": "Bearer {token}",
    "content-type": "application/json"
}

payload = {
    "model": "claude-sonnet-4-20250514",
    "max_tokens": 1024,
    "messages": [
        {
            "role": "user",
            "content": [
                {
                    "type": "image",
                    "source": {
                        "type": "url",
                        "url": "https://cdn.acedata.cloud/ueugot.png"
                    }
                },
                {
                    "type": "text",
                    "text": "Qu'est-ce qu'il y a dans cette image ?"
                }
            ]
        }
    ]
}

response = requests.post(url, json=payload, headers=headers)
print(response.json())

Exemple cURL

curl -X POST 'https://api.acedata.cloud/v1/messages' \
  -H 'accept: application/json' \
  -H 'authorization: Bearer {token}' \
  -H 'content-type: application/json' \
  -d '{
    "model": "claude-sonnet-4-20250514",
    "max_tokens": 1024,
    "messages": [
      {
        "role": "user",
        "content": [
          {
            "type": "image",
            "source": {
              "type": "url",
              "url": "https://cdn.acedata.cloud/ueugot.png"
            }
          },
          {
            "type": "text",
            "text": "Qu'est-ce qu'il y a dans cette image ?"
          }
        ]
      }
    ]
  }'

Les formats d’image pris en charge incluent : image/jpeg, image/png, image/gif, image/webp.

Documents et PDF

Les PDF utilisent le bloc de contenu document, prenant en charge les sources stables en Base64 et par URL. La source Base64 doit utiliser application/pdf :

import base64

with open("report.pdf", "rb") as f:
    pdf_data = base64.standard_b64encode(f.read()).decode("utf-8")

payload = {
    "model": "claude-fable-5-1",
    "max_tokens": 1024,
    "messages": [{
        "role": "user",
        "content": [
            {
                "type": "document",
                "source": {
                    "type": "base64",
                    "media_type": "application/pdf",
                    "data": pdf_data
                },
                "title": "Rapport trimestriel"
            },
            {"type": "text", "text": "Résumez ce PDF."}
        ]
    }]
}

La source par URL s’écrit {"type":"url","url":"https://example.com/report.pdf"}. Le document prend également en charge text/plain et les sources content composées de blocs textuels/images ; les champs optionnels incluent title, context et citations. La source file_id de l’API Files appartient à une fonctionnalité beta indépendante et n’est pas incluse dans le contrat stable de cette interface.

Mise en cache des invites

Le cache_control de niveau supérieur place automatiquement le point de rupture de cache à la fin du dernier bloc pouvant être mis en cache :

payload = {
    "model": "claude-fable-5-1",
    "max_tokens": 1024,
    "cache_control": {"type": "ephemeral", "ttl": "5m"},
    "system": "Vous êtes un expert sur ce matériel de référence.",
    "messages": [{"role": "user", "content": "Résumez les points clés."}]
}

Lorsque vous devez contrôler précisément l’emplacement, vous pouvez également écrire le même cache_control dans les blocs de contenu textuels, d’images, de documents, d’utilisation d’outils ou de résultats d’outils. Le ttl prend en charge 5m (par défaut) et 1h ; veuillez utiliser usage.cache_creation_input_tokens et usage.cache_read_input_tokens pour évaluer l’écriture et la réussite du cache. Exemple de résultat retourné :

{
  "id": "msg_01NCrxpZmV17bhQJJRQEFEb9",
  "type": "message",
  "role": "assistant",
  "content": [
    {
      "type": "text",
      "text": "Cette image montre une interface de configuration de requête API pour ce qui semble être un service de complétion de chat AI. L'interface comprend des paramètres pour la sélection du modèle, les messages, le mode de flux et les paramètres de tokens maximum."
    }
  ],
  "model": "claude-sonnet-4-20250514",
  "stop_reason": "end_turn",
  "stop_sequence": null,
  "usage": {
    "input_tokens": 1570,
    "output_tokens": 52
  }
}

Appel d’outils (Tool Use)

L’API Messages de Claude prend en charge nativement la fonctionnalité d’appel d’outils, permettant au modèle d’appeler vos outils/fonctions prédéfinis en cas de besoin.

Exemple Python

import requests

url = "https://api.acedata.cloud/v1/messages"

headers = {
    "accept": "application/json",
    "authorization": "Bearer {token}",
    "content-type": "application/json"
}

payload = {
    "model": "claude-sonnet-4-20250514",
    "max_tokens": 1024,
    "tools": [
        {
            "name": "get_weather",
            "description": "Obtenir la météo actuelle dans un lieu donné",
            "input_schema": {
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "La ville et l'état, par exemple San Francisco, CA"
                    }
                },
                "required": ["location"]
            }
        }
    ],
    "messages": [
        {"role": "user", "content": "Quel temps fait-il à San Francisco ?"}
    ]
}

response = requests.post(url, json=payload, headers=headers)
print(response.json())

Lorsque le modèle décide d’appeler un outil, le content du résultat retourné contiendra un bloc de contenu de type tool_use :

{
  "id": "msg_01Aq9w938a90dw8q",
  "type": "message",
  "role": "assistant",
  "content": [
    {
      "type": "text",
      "text": "Laissez-moi vérifier la météo à San Francisco pour vous."
    },
    {
      "type": "tool_use",
      "id": "toolu_01A09q90qw90lq917835lgs",
      "name": "get_weather",
      "input": {
        "location": "San Francisco, CA"
      }
    }
  ],
  "model": "claude-sonnet-4-20250514",
  "stop_reason": "tool_use",
  "stop_sequence": null,
  "usage": {
    "input_tokens": 120,
    "output_tokens": 68
  }
}

Notez que stop_reason est tool_use, ce qui indique que le modèle a besoin d’appeler un outil. Après avoir reçu ce résultat, vous devez exécuter la fonction de l’outil et renvoyer le résultat sous la forme de tool_result au modèle :

payload = {
    "model": "claude-sonnet-4-20250514",
    "max_tokens": 1024,
    "tools": [
        {
            "name": "get_weather",
            "description": "Obtenez la météo actuelle dans un lieu donné",
            "input_schema": {
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "La ville et l'état, par exemple San Francisco, CA"
                    }
                },
                "required": ["location"]
            }
        }
    ],
    "messages": [
        {"role": "user", "content": "Quel temps fait-il à San Francisco ?"},
        {
            "role": "assistant",
            "content": [
                {"type": "text", "text": "Laissez-moi vérifier la météo à San Francisco pour vous."},
                {"type": "tool_use", "id": "toolu_01A09q90qw90lq917835lgs", "name": "get_weather", "input": {"location": "San Francisco, CA"}}
            ]
        },
        {
            "role": "user",
            "content": [
                {
                    "type": "tool_result",
                    "tool_use_id": "toolu_01A09q90qw90lq917835lgs",
                    "content": "Ensoleillé, 72°F"
                }
            ]
        }
    ]
}

response = requests.post(url, json=payload, headers=headers)
print(response.json())

Le modèle générera une réponse en langage naturel finale basée sur les résultats retournés par l’outil.

Différences avec l’API de Chat Completion

Ace Data Cloud propose deux formats d’API Claude, les principales différences sont les suivantes : L’usage.input_tokens de l’API Messages ne représente que les entrées non mises en cache, cache_read_input_tokens et cache_creation_input_tokens sont des seaux de facturation indépendants ; les trois seront facturés selon les prix correspondants.

Caractéristique	API Messages (`/v1/messages`)	API Chat Completion (`/v1/chat/completions`)
Format	Format natif d’Anthropic	Format compatible OpenAI
Invite système	Champ `system` indépendant	Transmis via `role: "system"` dans `messages`
Structure de réponse	Tableau `content` (supporte plusieurs types)	Tableau `choices` (contient `message`)
Format en continu	Événements SSE (plusieurs types d’événements)	Lignes SSE `data`
Pensée approfondie	Paramètre `thinking` natif	Déclenché par un nom de modèle spécial (comme le suffixe `-thinking`)
Appel d’outils	`tools` natif + `input_schema`	Format `functions` compatible OpenAI
Statistiques de Token	`input_tokens` / `output_tokens`	`prompt_tokens` / `completion_tokens`

Si votre système est déjà intégré à l’API au format OpenAI, vous pouvez utiliser l’API Chat Completion pour une transition fluide. Si vous avez besoin d’utiliser toutes les capacités natives de Claude, il est recommandé d’utiliser l’API Messages.

Gestion des erreurs

Les réponses d’erreur de l’interface publique utilisent l’enveloppe de la plateforme Ace Data Cloud : error.code est un code d’erreur stable, error.message est une explication, trace_id est utilisé pour le dépannage des requêtes. Les états HTTP courants incluent :

400 : Paramètres de requête ou contenu de protocole invalides.
401 : Jeton d’autorisation invalide, manquant ou expiré.
403 : Accès interdit, solde insuffisant ou quota limité.
404 : API ou modèle introuvable.
413 : Corps de la requête trop volumineux.
429 : Trop de requêtes.
500 / 503 / 504 : Erreur de service, temporairement indisponible ou délai de traitement dépassé.

Exemple de réponse d’erreur

{
  "error": {
    "code": "api_error",
    "message": "échec de la récupération"
  },
  "trace_id": "2cf86e86-22a4-46e1-ac2f-032c0f2a4e89"
}

Cette structure d’erreur est le contrat d’exécution d’Ace Data Cloud, elle n’est pas équivalente à l’enveloppe d’erreur officielle d’Anthropic ; veuillez traiter selon l’état HTTP et error.code.

Conclusion

Grâce à ce document, vous avez compris comment utiliser l’API Messages de Claude au format natif d’Anthropic pour appeler les fonctionnalités de conversation de Claude. L’API Messages prend en charge des fonctionnalités riches telles que la conversation de base, les invites système, les réponses en continu, les conversations multi-tours, la pensée approfondie, la compréhension visuelle, les PDF, le cache d’invite et les appels d’outils. Si vous avez des questions, n’hésitez pas à contacter notre équipe de support technique.

Démarrage

Chat IA

Image IA

Vidéo IA

Audio IA

Web & Données

CAPTCHA

Identité

Proxy

Avancé

Coding

Demande et utilisation de l'API Claude Messages

Processus de demande

Utilisation de base

Exemple cURL

Exemple Python

Mot d’invite système

Exemple Python

Réponse en continu

Exemple Python

Exemple JavaScript

Dialogue multi-tours

Exemple Python

Modèle de réflexion approfondie

Modèle visuel

Utiliser des images encodées en Base64

Utiliser des images par URL

Exemple cURL

Documents et PDF

Mise en cache des invites

Appel d’outils (Tool Use)

Exemple Python

Différences avec l’API de Chat Completion

Gestion des erreurs

Exemple de réponse d’erreur

Conclusion

​Processus de demande

​Utilisation de base

​Exemple cURL

​Exemple Python

​Mot d’invite système

​Exemple Python

​Réponse en continu

​Exemple Python

​Exemple JavaScript

​Dialogue multi-tours

​Exemple Python

​Modèle de réflexion approfondie

​Modèle visuel

​Utiliser des images encodées en Base64

​Utiliser des images par URL

​Exemple cURL

​Documents et PDF

​Mise en cache des invites

​Appel d’outils (Tool Use)

​Exemple Python

​Différences avec l’API de Chat Completion

​Gestion des erreurs

​Exemple de réponse d’erreur

​Conclusion

Processus de demande

Utilisation de base

Exemple cURL

Exemple Python

Mot d’invite système

Exemple Python

Réponse en continu

Exemple Python

Exemple JavaScript

Dialogue multi-tours

Exemple Python

Modèle de réflexion approfondie

Modèle visuel

Utiliser des images encodées en Base64

Utiliser des images par URL

Exemple cURL

Documents et PDF

Mise en cache des invites

Appel d’outils (Tool Use)

Exemple Python

Différences avec l’API de Chat Completion

Gestion des erreurs

Exemple de réponse d’erreur

Conclusion