Comment obtenir une clé API Anthropic et faire votre première requête Claude

Une clé API Anthropic est l'identifiant que vous envoyez avec chaque requête à l'API Claude. Elle commence par sk-ant-, vous la créez dans la Console Claude, et elle facture l'utilisation sur les crédits prépayés de votre organisation. Si vous n'en avez jamais utilisé, notre introduction sur ce qu'est une clé API en couvre l'idée générale. Ce guide couvre celle-ci en particulier : créer un compte Console, charger des crédits, générer une clé avec la bonne portée, envoyer la première requête Messages avec curl et le SDK Python, et ensuite protéger la clé.

La page officielle d'Anthropic obtenir votre clé API vous indique où se trouve le bouton. Elle ne vous dit pas pourquoi la première requête renvoie une erreur 401, quel identifiant de modèle est actuel, ou comment tester la clé sans la coller dans l'historique de votre shell. C'est ce que couvre le reste de ce guide.

Ce dont vous avez besoin avant de commencer

• Un e-mail pour la Console Claude sur platform.claude.com (console.anthropic.com y redirige désormais).

• Une carte de paiement. L'API est prépayée, et seuls les rôles Admin ou Facturation peuvent acheter des crédits.
• curl, ou Python 3.10+ pour l'exemple du SDK.
• Apidog pour stocker la clé en tant que variable locale et enregistrer la requête comme test reproductible. Le plan gratuit couvre les équipes jusqu'à quatre personnes.

Étape 1 : créer un compte Console Claude

Inscrivez-vous sur platform.claude.com. Cela crée une organisation avec un Espace de travail par défaut, et vos clés, crédits et limites de débit en dépendent tous. Si un coéquipier en a déjà créé une, demandez une invitation plutôt que de créer une deuxième organisation : les crédits et les paliers d'utilisation ne sont pas transférables.

Étape 2 : ajouter des crédits avant votre premier appel

Oui, les crédits sont prioritaires. La documentation de facturation d'Anthropic est claire : achetez des crédits avant d'utiliser l'API, et avec un solde nul, ni l'API ni l'environnement de test ne fonctionnent. Les nouveaux utilisateurs reçoivent une petite quantité de crédits gratuits pour tester, alors vérifiez votre solde avant d'acheter, mais considérez cela comme un bonus plutôt qu'un plan.

Ouvrez Paramètres > Facturation et cliquez sur Acheter des crédits. Activez le rechargement automatique si vous utilisez un système sans surveillance. Consultez comment acheter des crédits pour les étapes actuelles. Votre organisation se retrouve également sur un palier d'utilisation avec un plafond de dépenses mensuel, couvert dans la section sur les limites de débit.

Étape 3 : créer la clé API

Allez dans Paramètres > Clés API et cliquez sur Créer une clé. Quatre choix sont importants :

• Nom : nommez-la d'après l'application, pas la personne. orders-service-staging est préférable à ma clé.
• Expiration : 3 heures à 30 jours, personnalisé, ou Jamais. Choisissez une courte durée de vie pour les tests ; elle ne pourra pas être modifiée plus tard.
• Compte lié : vous-même pour une clé personnelle, un compte de service pour tout ce qui est partagé. Une clé personnelle expire lorsque vous quittez l'organisation.
• Espace de travail : limitez-la à un seul espace de travail et vous pourrez ignorer l'en-tête anthropic-workspace-id. Une clé multi-espaces de travail doit l'envoyer avec chaque requête ou vous obtiendrez un 400.

La Console affiche la clé complète une seule fois, alors copiez-la directement dans votre gestionnaire de secrets. Il n'y a pas de bouton de révélation. Si Créer une clé est grisé, votre rôle ne peut pas créer de clés ; demandez à un administrateur.

Étape 4 : les trois en-têtes nécessaires à chaque requête

Chaque appel à POST https://api.anthropic.com/v1/messages comporte trois en-têtes.

Les SDK officiels les envoient tous les trois pour vous. Les clients HTTP bruts et API doivent les spécifier explicitement, ce qui est la cause de la plupart des échecs de première requête. Référence complète : Aperçu de l'API Claude.

Étape 5 : envoyer votre première requête Messages

Le corps nécessite model, max_tokens et messages. Utilisez un identifiant de modèle actuel : en septembre 2026, il s'agit de claude-opus-5 (le défaut recommandé), claude-fable-5-1 (le plus performant), claude-sonnet-5 et claude-haiku-4-5. Les identifiants plus anciens 3.x et 4.x renvoient 404 ou pointent vers des modèles retirés, et les identifiants actuels n'ont pas de suffixe de date. La présentation détaillée de l'API Claude Opus 5 approfondit la réflexion, l'effort et le streaming.

curl

export ANTHROPIC_API_KEY="sk-ant-api03-..."

curl https://api.anthropic.com/v1/messages \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "content-type: application/json" \
  -d '{
    "model": "claude-opus-5",
    "max_tokens": 1024,
    "messages": [
      {"role": "user", "content": "Write a one-sentence OpenAPI description for POST /orders, which creates an order and returns 201."}
    ]
  }'

Une réponse réussie, tronquée :

{
  "id": "msg_01...",
  "role": "assistant",
  "model": "claude-opus-5",
  "content": [{"type": "text", "text": "Creates a new order and returns it with a 201 status."}],
  "stop_reason": "end_turn",
  "usage": {"input_tokens": 31, "output_tokens": 24}
}

Lisez le texte de content[].text, vérifiez que stop_reason est end_turn, et conservez usage pour le suivi des coûts. L'en-tête de réponse request-id est ce que le support demande en cas d'échec.

SDK Python

pip install anthropic

import anthropic

client = anthropic.Anthropic()  # reads ANTHROPIC_API_KEY from the environment

message = client.messages.create(
    model="claude-opus-5",
    max_tokens=1024,
    messages=[{
        "role": "user",
        "content": "Write a one-sentence OpenAPI description for POST /orders, which creates an order and returns 201.",
    }],
)

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

Le SDK lit ANTHROPIC_API_KEY, ajoute les en-têtes de version et de type de contenu, et retente les erreurs 429 et 5xx deux fois avec un mécanisme de temporisation (backoff). Ne passez jamais la clé en tant que chaîne littérale ; la variable d'environnement est l'objectif principal.

Étape 6 : stocker et tester la clé dans Apidog

Une clé collée dans un shell reste dans votre fichier d'historique. Une clé stockée dans une requête partagée est synchronisée avec les coéquipiers. Apidog sépare les deux : la structure de la requête est partagée, le secret reste sur votre machine.

Stockez la clé comme une variable locale. Ouvrez Gestion de l'environnement, créez un environnement appelé Anthropic, et ajoutez une variable ANTHROPIC_API_KEY. Laissez la valeur partagée comme SET_LOCALLY et collez la vraie clé dans la valeur locale, qui reste dans le cache de votre client et ne se synchronise jamais. Notre guide sur les environnements et variables secrètes d'Apidog couvre les règles de portée.

Définissez les en-têtes une fois. Dans le même panneau, ajoutez deux paramètres globaux sous En-têtes : x-api-key défini sur {{ANTHROPIC_API_KEY}}, et anthropic-version défini sur 2023-06-01. Ils s'appliquent à chaque requête du projet, et Apidog ajoute automatiquement content-type pour un corps JSON.

Envoyez la première requête. Nouvelle requête, POST vers https://api.anthropic.com/v1/messages, collez le corps JSON de l'exemple curl, envoyez. Ouvrez l'onglet Requête réelle pour confirmer que les deux en-têtes ont été envoyés avec la variable résolue. Cet onglet est le moyen le plus rapide de prouver qu'une erreur 401 est un problème d'en-tête, et non un problème de clé.

Enregistrez-le comme test. Enregistrez la requête comme un cas de point de terminaison, puis ajoutez trois assertions : le statut est égal à 200, stop_reason est égal à end_turn, et usage.output_tokens est supérieur à 0. Exécutez-le depuis l'interface de ligne de commande d'Apidog et injectez la clé depuis votre magasin de secrets CI au moment de l'exécution. C'est un test de fumée en un clic pour la clé, les en-têtes et l'identifiant du modèle. Téléchargez Apidog pour suivre ; le plan gratuit inclut quatre sièges.

Limites de débit et coût d'une requête

Les limites sont par organisation et par modèle : requêtes par minute (RPM), jetons d'entrée par minute (ITPM) et jetons de sortie par minute (OTPM). Seule l'entrée non mise en cache compte pour l'ITPM, de sorte que la mise en cache des prompts augmente le débit sans changer de palier. D'après la documentation sur les limites de débit :

Sonnet 5 et Haiku 4.5 partagent les chiffres d'Opus 5 à chaque palier. Chaque réponse contient les en-têtes anthropic-ratelimit-*-remaining et -reset, vous permettant de surveiller la marge disponible sans interroger la Console.

Par million de jetons, d'après la page de tarification : Opus 5 coûte 5 $ en entrée / 25 $ en sortie, Sonnet 5 2 $ / 10 $, Fable 5.1 10 $ / 50 $, Haiku 4.5 1 $ / 5 $. Les lectures de cache coûtent 10 % de l'entrée (2,5 % sur Fable 5.1) et l'API Batch réduit de moitié les deux côtés. Cette première requête curl coûte une fraction de centime.

Erreurs courantes et comment les résoudre

Les erreurs sont renvoyées en JSON avec un error.type et un request_id. La référence des erreurs liste tous les codes ; ce sont ceux que vous rencontrerez en premier.

Hygiène des clés : rotation, portée et jamais dans le code client

N'envoyez jamais la clé à un navigateur ou une application mobile. Tout ce qui se trouve dans un bundle JavaScript ou un APK est public en quelques minutes. Placez l'appel derrière votre propre backend. Pour les applications Apple qui doivent appeler Claude directement, App Attest émet des jetons de courte durée pour les builds vérifiés au lieu d'une clé statique.

Une clé par application et par environnement. Des clés de pré-production et de production séparées dans des espaces de travail distincts vous permettent de plafonner les dépenses de pré-production et de révoquer l'une sans toucher à l'autre.

Faites pivoter (changez) régulièrement. Créez la nouvelle clé, déployez, confirmez qu'elle fonctionne, puis supprimez l'ancienne. Désactiver est réversible ; Supprimer est permanent. Si vous suspectez une fuite, désactivez d'abord et enquêtez ensuite. Un scanner de secrets dans votre dépôt détecte les clés commises avant que quiconque ne les remarque.

Préférez les identifiants de courte durée en production. Workload Identity Federation échange le jeton d'identité de votre fournisseur cloud contre un jeton Claude de courte durée, de sorte qu'il n'y a aucune chaîne sk-ant- à divulguer.

FAQ

Une clé API Anthropic est-elle la même chose qu'une clé API Claude ?

Oui. La Console, les SDK et la documentation disent maintenant « API Claude », et le format de clé et les en-têtes sont identiques. Les tutoriels plus anciens mentionnant « clé API Anthropic » désignent le même identifiant.

Puis-je obtenir une clé API Anthropic gratuitement ?

La création de la clé est gratuite. Son utilisation puise dans des crédits prépayés, et la page de tarification d'Anthropic indique que les nouveaux utilisateurs reçoivent une petite quantité de crédits gratuits pour tester. Si vous essayez d'exécuter de véritables charges de travail sans payer, lisez notre analyse honnête sur l'accès gratuit à l'API Claude avant de vous baser là-dessus.

Un abonnement Claude Pro ou Max inclut-il l'accès à l'API ?

Non. Les abonnements Claude.ai et les crédits de l'API Console sont facturés séparément. Vous avez besoin d'une organisation Console avec des crédits, même si vous payez déjà pour Claude.ai.

Que se passe-t-il lorsque ma clé expire ?

Les requêtes renvoient 401 authentication_error. Les clés expirées ne peuvent pas être réactivées, alors créez-en une nouvelle et mettez à jour la variable d'environnement. Anthropic envoie un e-mail au créateur de la clé sept jours et un jour avant l'expiration pour les clés ayant une durée de vie suffisante.

Étape suivante

Créez la clé avec une expiration de 7 jours, placez-la dans une variable locale Apidog, exécutez le test de fumée, et seulement ensuite intégrez-la au code. Si cela réussit, l'identifiant, les en-têtes et l'identifiant du modèle sont tous corrects, et chaque 401 après cela est un vrai problème plutôt qu'une faute de frappe.