API Anthropic : démarrer en 30 minutes (guide en français)

Ce guide t'amène d'un compte inexistant à un script Python (ou Node) qui répond en moins de trente minutes. On code pendant qu'on lit. Chaque section produit un résultat vérifiable : une clé générée, un appel qui retourne du texte, un coût estimé sur la base de ton usage réel. Pour le contexte plus large sur l'écosystème, va voir le guide complet pour apprendre Claude. Ici on reste sur l'API.

Si tu débutes complètement sur Claude côté chat, un détour par le premier prompt Claude peut aider. Sinon, saute directement à la section suivante.

Ce qu'il faut avoir avant de commencer

Deux mondes cohabitent chez Anthropic, et beaucoup de praticiens perdent une heure à comprendre pourquoi. Claude.ai est l'interface chat, facturée à partir de 20 € par mois pour Pro. console.anthropic.com est la console développeur, facturée à l'usage sur l'API. Les deux comptes sont séparés, les deux factures sont séparées. Payer Claude Pro ne donne aucun crédit API, et inversement.

Prérequis concrets pour la suite :

• Une adresse email et un mot de passe pour créer le compte console
• Une carte bancaire pour ajouter des crédits (l'API ne fournit qu'un petit crédit initial, généralement autour de 5 $, insuffisant pour un projet réel)
• Python 3.8 ou plus récent, ou Node 18 ou plus récent
• Un terminal et un éditeur (VS Code, Cursor, Zed, ce que tu veux)

Depuis la France, la Belgique, la Suisse ou le Canada, l'accès est direct. Pas de VPN, pas de contournement. Si tu compares les offres avant de te décider entre chat et API, la page configurer Claude et choisir son abonnement détaille les cas d'usage typiques.

Créer un compte et générer une clé API

Rendez-vous sur console.anthropic.com. Signup avec ton email pro (pas ton adresse Claude.ai personnelle si tu veux séparer proprement). Vérification par email, puis création d'une Organization. Une org peut contenir plusieurs projets, plusieurs clés, plusieurs membres. Nomme-la avec le nom de ton entreprise, pas "test".

Une fois dans la console :

1. Onglet Settings dans la sidebar
2. Sous-onglet API Keys
3. Bouton Create Key
4. Nomme la clé par projet et environnement : ottho-prod-2026, chatbot-support-dev, jamais juste "ma clé"
5. Copie la clé immédiatement, elle ne sera plus visible ensuite

Deux règles non négociables : la clé ne va jamais dans un fichier committé sur git, et chaque projet a sa propre clé pour pouvoir couper l'accès en cas de fuite sans tout casser. Stocke la clé dans un fichier .env, ajoute .env à ton .gitignore avant même le premier commit.

Dernier point avant de coder : ajoute un premier crédit. Settings > Billing > Add credits. Entre 5 et 20 $ suffisent pour les tests de cette journée. Tu peux configurer un auto-recharge plus tard, une fois que tu connais ta consommation.

Ton premier appel API en Python

Dans un nouveau dossier :

pip install anthropic python-dotenv

Crée un fichier .env à côté de ton script :

ANTHROPIC_API_KEY=sk-ant-api03-...

Puis un fichier first_call.py :

from anthropic import Anthropic
from dotenv import load_dotenv

load_dotenv()
client = Anthropic()

message = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    messages=[
        {"role": "user", "content": "Explique en trois phrases ce qu'est un token LLM."}
    ]
)

print(message.content[0].text)

Lance avec python first_call.py. Tu obtiens une réponse texte en trois phrases. Si ça marche du premier coup, tu es à quinze minutes du démarrage.

Les trois paramètres qui comptent vraiment :

• model : identifiant du modèle. On voit les valeurs valides dans la section "Choisir le bon modèle".
• max_tokens : plafond de la réponse. Mets 1024 pour tester, monte à 4096 ou plus pour des tâches longues.
• messages : liste des tours de conversation, chaque entrée a un role (user ou assistant) et un content.

Les autres paramètres utiles, en une phrase :

• system : instructions persistantes hors conversation (ton, rôle, contraintes)
• temperature : 0 pour du déterministe, 1 pour du créatif, 0.7 par défaut
• stop_sequences : chaînes qui coupent la génération

Le même appel en Node.js

Setup équivalent côté JavaScript ou TypeScript :

npm install @anthropic-ai/sdk dotenv

Fichier firstCall.ts :

import Anthropic from "@anthropic-ai/sdk";
import "dotenv/config";

const client = new Anthropic();

const message = await client.messages.create({
  model: "claude-sonnet-4-6",
  max_tokens: 1024,
  messages: [
    { role: "user", content: "Explique en trois phrases ce qu'est un token LLM." }
  ]
});

const block = message.content[0];
if (block.type === "text") {
  console.log(block.text);
}

La structure de réponse surprend souvent au premier appel : message.content est un tableau de blocs, pas une string. Chaque bloc a un type (text, tool_use, etc.). Pour du texte simple, on prend content[0].text. En TypeScript, le narrowing sur block.type === "text" évite les surprises quand tu ajouteras du tool use.

Choisir le bon modèle pour ton cas

La famille Claude compte plusieurs tiers. Voici l'état 2026 :

Règle pratique : commence sur Sonnet 4.6. C'est le point d'équilibre par défaut. Si le volume fait exploser la facture et que la tâche est simple (routage, extraction, classification), bascule sur Haiku 4.5. Si Sonnet échoue sur une tâche de raisonnement long ou de code agentique, monte sur Opus 4.7 ou Fable 5. Ne commence jamais sur le modèle le plus cher "pour être sûr", tu vas cramer ton budget sans comprendre où.

Comprendre la facturation avant de scaler

Les tokens se comptent en entrée et en sortie, à des tarifs différents. Ordre de grandeur : 1 token vaut environ 4 caractères en anglais, un peu plus en français à cause des accents et des mots plus longs. Une phrase de 20 mots en français, c'est autour de 30 tokens.

Exemple concret. Un chatbot support qui traite 1 000 conversations par jour, chaque conversation faisant en moyenne 500 tokens d'entrée (question + contexte système) et 300 tokens de sortie (réponse), sur Sonnet 4.6 :

• Input : 1 000 × 500 × 30 jours = 15 M tokens = 15 × 3 $ = 45 $/mois
• Output : 1 000 × 300 × 30 jours = 9 M tokens = 9 × 15 $ = 135 $/mois
• Total : environ 180 $/mois

La sortie coûte cinq fois l'entrée sur Sonnet. Si ta facture dérape, c'est presque toujours parce que le modèle génère trop long. Baisse max_tokens, demande des réponses concises dans le system prompt.

Côté rate limits, Anthropic fonctionne par tiers cumulés. Le tier 1 (démarrage) plafonne les requêtes par minute. Chaque palier de dépense cumulée débloque un tier supérieur avec plus de débit. Tu vois ta consommation en temps réel dans Settings > Usage. Pour comparer avec les tarifs concurrents, l'article Claude vs ChatGPT détaille les grilles côte à côte.

Les erreurs qui vont t'arriver

Quatre codes que tu verras dans la vraie vie :

• 401 Unauthorized : clé invalide, mal copiée, ou header manquant. Vérifie que ANTHROPIC_API_KEY est bien chargée. Le SDK officiel lit cette variable d'environnement automatiquement.
• 429 Too Many Requests : rate limit atteint. Implémente un backoff exponentiel (attendre 1s, puis 2s, puis 4s).
• 529 Overloaded : surcharge côté Anthropic. Retry après quelques secondes, ce n'est pas ton problème.
• max_tokens trop bas : la réponse est coupée en plein milieu, stop_reason vaut max_tokens. Monte la valeur.

Retry minimal en Python :

import time
from anthropic import APIStatusError

for attempt in range(3):
    try:
        message = client.messages.create(...)
        break
    except APIStatusError as e:
        if e.status_code in (429, 529) and attempt < 2:
            time.sleep(2 ** attempt)
            continue
        raise

Aller plus loin : streaming, tool use, MCP

Trois directions à creuser une fois que ton premier appel fonctionne.

Streaming. Passe stream=True pour recevoir la réponse token par token. Indispensable si tu construis une interface chat, sinon l'utilisateur attend cinq secondes devant un écran vide.

Tool use. Le modèle peut appeler des fonctions que tu définis (chercher dans ta base, envoyer un email, lire un fichier). C'est la porte d'entrée vers les agents. Pour te lancer côté agents, va lire construire ton premier agent Claude puis l'architecture d'agent.

MCP (Model Context Protocol). Standard ouvert créé par Anthropic pour brancher Claude sur des outils externes (Notion, Slack, GitHub, HubSpot) sans réécrire l'intégration à chaque fois. Détails techniques sur la fiche outil MCP, et un tutoriel pratique dans construire un serveur MCP. Pour la référence API complète, la fiche outil Anthropic API reste le point d'ancrage.

Passer à la pratique

À ce stade, tu as une clé, un script qui répond, une estimation de coût, et tu sais quel modèle prendre par défaut. Le reste s'apprend en construisant. Si tu veux industrialiser (chatbot en prod, agent connecté à ton CRM, automatisations métier), le pilier automatiser sa stack avec Claude et MCP couvre les patterns récurrents.

Pour aller plus vite avec un cadre et une cohorte, construire ton produit IA en 5 semaines avec Claude Builders est fait pour les leaders ops et builders qui veulent livrer, pas juste tester.