API Claude : Guide Pratique Python & TypeScript (2026)

Pourquoi Utiliser l'API Claude ?

L'API Claude est le moyen le plus direct d'intégrer l'intelligence artificielle d'Anthropic dans vos applications. Contrairement à l'interface web claude.ai, l'API vous donne un contrôle total sur :

• →Le modèle utilisé (Opus, Sonnet, Haiku)
• →Les paramètres de génération (température, max tokens, stop sequences)
• →Les fonctionnalités avancées (tool use, vision, extended thinking, streaming)
• →L'architecture d'intégration (temps réel, batch, webhooks)

Architecture de l'API

L'API Claude repose sur une architecture REST simple avec un seul endpoint principal :

POST https://api.anthropic.com/v1/messages

Chaque requête inclut :

1. →Un modèle (claude-sonnet-4-20250514, claude-opus-4-20250918, etc.)
2. →Des messages (conversation sous forme de tableau)
3. →Des paramètres optionnels (température, max_tokens, tools, etc.)

import anthropic

client = anthropic.Anthropic()  # Utilise ANTHROPIC_API_KEY

message = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    messages=[
        {"role": "user", "content": "Explique les microservices en 3 phrases."}
    ]
)
print(message.content[0].text)

Authentification et Configuration

Obtenir une Clé API

1. →Créez un compte sur console.anthropic.com
2. →Naviguez vers Settings > API Keys
3. →Cliquez Create Key et nommez-la descriptivelement
4. →Copiez la clé (elle ne sera plus affichée)

Configurer la Clé API

# Variable d'environnement (recommandé)
export ANTHROPIC_API_KEY="sk-ant-api03-..."

# Ou dans un fichier .env
echo 'ANTHROPIC_API_KEY=sk-ant-api03-...' >> .env

# Python - Automatique via variable d'environnement
client = anthropic.Anthropic()

# Python - Explicite
client = anthropic.Anthropic(api_key="sk-ant-api03-...")

// TypeScript - Automatique via variable d'environnement
const client = new Anthropic();

// TypeScript - Explicite
const client = new Anthropic({ apiKey: "sk-ant-api03-..." });

L'API Messages en Détail

L'API Messages est le cœur de l'interaction avec Claude. Voici la structure complète d'une requête :

import anthropic

client = anthropic.Anthropic()

response = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=2048,
    temperature=0.7,
    system="Tu es un expert en architecture logicielle.",
    messages=[
        {
            "role": "user",
            "content": "Quels sont les avantages des microservices ?"
        },
        {
            "role": "assistant",
            "content": "Les microservices offrent plusieurs avantages clés..."
        },
        {
            "role": "user",
            "content": "Et les inconvénients ?"
        }
    ],
    stop_sequences=["\n\nHuman:"]
)

print(response.content[0].text)
print(f"Tokens: {response.usage.input_tokens} in / {response.usage.output_tokens} out")

Paramètres Clés

Structure de la Réponse

{
  "id": "msg_01XFDUDYJgAACzvnptvVoYEL",
  "type": "message",
  "role": "assistant",
  "content": [
    {
      "type": "text",
      "text": "Les microservices offrent..."
    }
  ],
  "model": "claude-sonnet-4-20250514",
  "stop_reason": "end_turn",
  "usage": {
    "input_tokens": 42,
    "output_tokens": 156
  }
}

Streaming

Le streaming permet d'afficher la réponse de Claude en temps réel, token par token. Indispensable pour les interfaces utilisateur interactives.

import anthropic

client = anthropic.Anthropic()

with client.messages.stream(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Écris un poème sur le code."}]
) as stream:
    for text in stream.text_stream:
        print(text, end="", flush=True)

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

const client = new Anthropic();

const stream = client.messages.stream({
  model: "claude-sonnet-4-20250514",
  max_tokens: 1024,
  messages: [{ role: "user", content: "Écris un poème sur le code." }],
});

for await (const event of stream) {
  if (
    event.type === "content_block_delta" &&
    event.delta.type === "text_delta"
  ) {
    process.stdout.write(event.delta.text);
  }
}

Événements de Streaming

API Batch : Traitement en Masse

L'API Batch permet d'envoyer jusqu'à 100 000 requêtes dans un seul lot, avec un coût réduit de 50% et un délai de traitement allant jusqu'à 24 heures.

import anthropic

client = anthropic.Anthropic()

# Créer un batch
batch = client.batches.create(
    requests=[
        {
            "custom_id": "req-1",
            "params": {
                "model": "claude-sonnet-4-20250514",
                "max_tokens": 1024,
                "messages": [
                    {"role": "user", "content": "Résume cet article : ..."}
                ]
            }
        },
        {
            "custom_id": "req-2",
            "params": {
                "model": "claude-sonnet-4-20250514",
                "max_tokens": 1024,
                "messages": [
                    {"role": "user", "content": "Traduis ce texte : ..."}
                ]
            }
        }
    ]
)

# Vérifier le statut
status = client.batches.retrieve(batch.id)
print(f"Statut: {status.processing_status}")

# Récupérer les résultats quand c'est prêt
if status.processing_status == "ended":
    for result in client.batches.results(batch.id):
        print(f"{result.custom_id}: {result.result.message.content[0].text}")

Quand Utiliser l'API Batch ?

SDKs Officiels

Anthropic fournit des SDKs pour les principaux langages de programmation :

Exemple Java

import com.anthropic.client.AnthropicClient;
import com.anthropic.models.*;

AnthropicClient client = AnthropicClient.builder()
    .apiKey(System.getenv("ANTHROPIC_API_KEY"))
    .build();

MessageCreateParams params = MessageCreateParams.builder()
    .model("claude-sonnet-4-20250514")
    .maxTokens(1024)
    .addUserMessage("Bonjour Claude !")
    .build();

Message message = client.messages().create(params);
System.out.println(message.content().get(0).text());

Exemple Go

package main

import (
    "context"
    "fmt"
    "github.com/anthropics/anthropic-sdk-go"
)

func main() {
    client := anthropic.NewClient()

    message, err := client.Messages.New(context.Background(),
        anthropic.MessageNewParams{
            Model:     anthropic.ModelClaudeSonnet4_20250514,
            MaxTokens: 1024,
            Messages: []anthropic.MessageParam{
                anthropic.NewUserMessage(
                    anthropic.NewTextBlock("Bonjour Claude !"),
                ),
            },
        },
    )
    if err != nil {
        panic(err)
    }
    fmt.Println(message.Content[0].Text)
}

Gestion d'Erreurs

L'API Claude utilise des codes HTTP standard et des messages d'erreur descriptifs.

Gestion Robuste des Erreurs

import anthropic
import time

client = anthropic.Anthropic()

def call_claude_with_retry(messages, max_retries=3):
    for attempt in range(max_retries):
        try:
            return client.messages.create(
                model="claude-sonnet-4-20250514",
                max_tokens=1024,
                messages=messages
            )
        except anthropic.RateLimitError:
            wait = 2 ** attempt  # Exponential backoff
            print(f"Rate limited. Attente de {wait}s...")
            time.sleep(wait)
        except anthropic.APIStatusError as e:
            if e.status_code >= 500:
                time.sleep(1)
                continue
            raise
    raise Exception("Nombre maximum de tentatives atteint")

Rate Limits

Les rate limits protègent la stabilité de l'API et varient selon votre tier d'utilisation.

Les headers de réponse incluent vos limites actuelles :

anthropic-ratelimit-requests-limit: 4000
anthropic-ratelimit-requests-remaining: 3999
anthropic-ratelimit-requests-reset: 2026-03-10T12:00:30Z
anthropic-ratelimit-tokens-limit: 400000
anthropic-ratelimit-tokens-remaining: 399800

Tarification

Calcul rapide : Une conversation typique (500 tokens in + 500 tokens out) avec Sonnet coûte environ $0.009 — moins d'un centime.

Patterns Courants

Conversation Multi-tours

conversation = []

def chat(user_message):
    conversation.append({"role": "user", "content": user_message})
    
    response = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=2048,
        system="Tu es un assistant de développement Python expert.",
        messages=conversation
    )
    
    assistant_message = response.content[0].text
    conversation.append({"role": "assistant", "content": assistant_message})
    return assistant_message

# Utilisation
print(chat("Comment créer une API REST avec FastAPI ?"))
print(chat("Ajoute de l'authentification JWT."))
print(chat("Maintenant ajoute des tests."))

Sortie Structurée (JSON)

import json

response = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    messages=[{
        "role": "user",
        "content": """Analyse ce texte et retourne un JSON structuré :
        
        "Le produit est excellent, livraison rapide mais emballage abîmé."
        
        Format attendu :
        {"sentiment": "positif|négatif|mixte", "aspects": [...], "score": 0-10}"""
    }]
)

result = json.loads(response.content[0].text)
print(result)
# {"sentiment": "mixte", "aspects": [...], "score": 7}

System Prompt avec Contexte

response = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=2048,
    system="""Tu es un assistant pour la plateforme e-commerce "TechShop".

Règles :
- Réponds toujours en français
- Recommande uniquement des produits du catalogue
- Si tu ne connais pas la réponse, redirige vers le support

Catalogue actuel :
- MacBook Pro M4 : 2499€
- iPhone 16 Pro : 1299€
- iPad Air M3 : 799€""",
    messages=[
        {"role": "user", "content": "Quel ordinateur portable me recommandez-vous ?"}
    ]
)

Accès via les Clouds

L'API Claude est également disponible via les principaux fournisseurs cloud :

Bonnes Pratiques

1. →Utilisez des variables d'environnement pour les clés API — jamais en dur dans le code
2. →Implémentez le retry avec backoff exponentiel pour gérer les erreurs transitoires
3. →Monitorez votre usage via la console Anthropic pour éviter les surprises
4. →Utilisez le streaming pour les interfaces utilisateur interactives
5. →Préférez l'API Batch pour les traitements en masse (50% d'économie)
6. →Activez le prompt caching pour les prompts systèmes répétitifs
7. →Choisissez le bon modèle : Haiku pour les tâches simples, Sonnet pour l'usage général, Opus pour le raisonnement complexe

Ressources

Pour aller plus loin

• →Streaming API avec Claude : guide pratique — Maîtrisez le streaming SSE pour des réponses en temps réel
• →Sorties structurées et mode strict — Garantissez des sorties JSON valides avec le paramètre strict