---
title: SDK TypeScript
url: https://platform.claude.com/docs/fr/cli-sdks-libraries/sdks/typescript
description: Installez et configurez le SDK TypeScript d'Anthropic pour les environnements Node.js, Deno, Bun et navigateur
---

Cette bibliothèque fournit un accès pratique à l'API Claude depuis TypeScript ou JavaScript.

<Info>
  Pour la documentation des fonctionnalités de l'API avec des exemples de code, consultez la [référence de l'API](https://platform.claude.com/docs/fr/api/overview). Cette page couvre les fonctionnalités et la configuration du SDK spécifiques à TypeScript.
</Info>

## Installation

```bash
npm install @anthropic-ai/sdk
```

## Prérequis

TypeScript >= 5.0 est pris en charge.

Les environnements d'exécution suivants sont pris en charge :

* Node.js 20 LTS ou versions ultérieures ([non EOL](https://endoflife.date/nodejs)).
* Deno v1.28.0 ou supérieur.
* Bun 1.0 ou ultérieur.
* Cloudflare Workers.
* Vercel Edge Runtime.
* Jest 28 ou supérieur avec l'environnement `"node"` (`"jsdom"` n'est pas pris en charge pour le moment).
* Nitro v2.6 ou supérieur.
* Navigateurs web : désactivés par défaut pour éviter d'exposer vos identifiants API secrets (consultez les [bonnes pratiques relatives aux clés API](https://support.claude.com/en/articles/9767949-api-key-best-practices-keeping-your-keys-safe-and-secure)). Activez la prise en charge des navigateurs en définissant explicitement `dangerouslyAllowBrowser` sur `true`.

Notez que React Native n'est pas pris en charge pour le moment.

Si d'autres environnements d'exécution vous intéressent, ouvrez une issue ou votez pour une issue existante sur le [dépôt GitHub](https://github.com/anthropics/anthropic-sdk-typescript).

## Utilisation

```typescript
const client = new Anthropic({
  apiKey: process.env["ANTHROPIC_API_KEY"] // This is the default and can be omitted
});

const message = await client.messages.create({
  max_tokens: 1024,
  messages: [{ role: "user", content: "Hello, Claude" }],
  model: "claude-opus-5-5"
});

for (const block of message.content) {
  if (block.type === "text") {
    console.log(block.text);
  }
}
```

Pour les options d'authentification, y compris la fédération d'identité de charge de travail (Workload Identity Federation), consultez [Authentification](https://platform.claude.com/docs/fr/manage-claude/authentication). Si votre clé API est une [clé de compte personnel ou de compte de service](https://platform.claude.com/docs/fr/manage-claude/authentication#key-types) qui n'est pas limitée à un espace de travail, définissez l'ID de l'espace de travail dans l'en-tête de requête `anthropic-workspace-id` ; [Sélectionner un espace de travail](https://platform.claude.com/docs/fr/manage-claude/authentication#select-a-workspace) présente l'option par requête pour ce SDK.

## Types de requête et de réponse

Cette bibliothèque inclut des définitions TypeScript pour tous les paramètres de requête et champs de réponse. Vous pouvez les importer et les utiliser ainsi :

```typescript
const client = new Anthropic({
  apiKey: process.env["ANTHROPIC_API_KEY"] // This is the default and can be omitted
});

const params: Anthropic.MessageCreateParams = {
  max_tokens: 1024,
  messages: [{ role: "user", content: "Hello, Claude" }],
  model: "claude-opus-5-5"
};
const message: Anthropic.Message = await client.messages.create(params);
```

La documentation de chaque méthode, paramètre de requête et champ de réponse est disponible dans les docstrings et s'affiche au survol dans la plupart des éditeurs modernes.

## Comptage des tokens

Vous pouvez consulter l'utilisation exacte d'une requête donnée grâce à la propriété de réponse `usage`, par exemple :

```typescript
const message = await client.messages.create({
  max_tokens: 1024,
  messages: [{ role: "user", content: "Hello, Claude" }],
  model: "claude-opus-5-5"
});
console.log(message.usage);
// { input_tokens: 25, output_tokens: 13 }
```

## Réponses en streaming

Le SDK prend en charge les réponses en « streaming » (streaming) à l'aide des Server-Sent Events (SSE).

```typescript
const client = new Anthropic();

const stream = await client.messages.create({
  max_tokens: 1024,
  messages: [{ role: "user", content: "Hello, Claude" }],
  model: "claude-opus-5-5",
  stream: true
});
for await (const messageStreamEvent of stream) {
  console.log(messageStreamEvent.type);
}
```

Si vous devez annuler un stream, vous pouvez utiliser `break` pour sortir de la boucle ou appeler `stream.controller.abort()`.

## Utilitaires de streaming

Cette bibliothèque fournit plusieurs commodités pour le streaming de messages, par exemple :

```typescript
const anthropic = new Anthropic();

const stream = anthropic.messages
  .stream({
    model: "claude-opus-5-5",
    max_tokens: 1024,
    messages: [
      {
        role: "user",
        content: "Say hello there!"
      }
    ]
  })
  .on("text", (text) => {
    console.log(text);
  });

const message = await stream.finalMessage();
console.log(message);
```

Le streaming avec `client.messages.stream(...)` expose divers utilitaires pour votre commodité, notamment des gestionnaires d'événements et l'accumulation.

Vous pouvez également utiliser `client.messages.create({ ..., stream: true })`, qui renvoie uniquement un itérable asynchrone des événements du stream et utilise donc moins de mémoire (il ne construit pas d'objet message final pour vous).

## Utilitaires d'outils

Ce SDK fournit des utilitaires qui facilitent la création et l'exécution d'outils dans l'API Messages. Vous pouvez utiliser des schémas Zod ou des JSON Schemas pour décrire l'entrée d'un outil. Vous pouvez ensuite exécuter ces outils à l'aide de la méthode `client.beta.messages.toolRunner()`. Cette méthode se charge de transmettre les entrées générées par le modèle choisi au bon outil et de renvoyer le résultat au modèle.

Pour plus de détails sur l'« tool use » (utilisation d'outils), consultez [Utilisation d'outils avec Claude](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/overview). Pour exécuter l'outil d'utilisation du navigateur ou l'outil d'utilisation de l'ordinateur avec ce SDK, consultez [Utilisation du navigateur et de l'ordinateur avec les ensembles d'outils du SDK](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/browser-use-sdk).

```typescript
import { betaZodTool } from "@anthropic-ai/sdk/helpers/beta/zod";
import { z } from "zod";

const anthropic = new Anthropic();

const weatherTool = betaZodTool({
  name: "get_weather",
  inputSchema: z.object({
    location: z.string()
  }),
  description: "Get the current weather in a given location",
  run: (input) => {
    return `The weather in ${input.location} is foggy and 60°F`;
  }
});

const finalMessage = await anthropic.beta.messages.toolRunner({
  model: "claude-opus-5-5",
  max_tokens: 1000,
  messages: [{ role: "user", content: "What is the weather in San Francisco?" }],
  tools: [weatherTool]
});

console.log(finalMessage.content);
```

### Erreurs d'outils

Pour signaler une erreur d'un outil au modèle, levez une `ToolError` depuis la fonction `run`. Contrairement à une `Error` simple, `ToolError` accepte des blocs de contenu, ce qui vous permet d'inclure des images ou d'autres contenus structurés dans la réponse d'erreur :

```typescript
import { ToolError } from "@anthropic-ai/sdk/lib/tools/BetaRunnableTool";

const screenshotTool = betaZodTool({
  name: "take_screenshot",
  inputSchema: z.object({ url: z.string() }),
  run: async (input) => {
    if (!isValidUrl(input.url)) {
      throw new ToolError(`Invalid URL: ${input.url}`);
    }
    const result = await takeScreenshot(input.url);
    if (result.error) {
      // Inclure la capture d'écran de l'erreur pour que le modèle voie ce qui n'a pas fonctionné.
      throw new ToolError([
        { type: "text", text: `Failed to load page: ${result.error}` },
        {
          type: "image",
          source: { type: "base64", data: result.screenshot, media_type: "image/png" }
        }
      ]);
    }
    return {
      type: "image",
      source: { type: "base64", data: result.screenshot, media_type: "image/png" }
    };
  }
});
```

Si une `Error` simple est levée, le message sera converti en bloc de contenu texte.

## Utilisation d'outils

Ce SDK prend en charge l'utilisation d'outils, également appelée appel de fonctions. Pour plus de détails, consultez [Utilisation d'outils avec Claude](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/overview).

## Utilitaires MCP

Ce SDK fournit des utilitaires pour l'intégration avec les serveurs [Model Context Protocol (MCP)](https://modelcontextprotocol.io/). Ces utilitaires convertissent les types MCP en types de l'API Claude, réduisant ainsi le code répétitif lorsque vous travaillez avec des outils, prompts et ressources MCP.

<Tip>
  L'API Claude prend également en charge un [paramètre `mcp_servers`](https://platform.claude.com/docs/fr/agents-and-tools/mcp-connector) qui permet à Claude de se connecter directement à des serveurs MCP distants. Utilisez `mcp_servers` lorsque vous disposez de serveurs distants accessibles par URL et que vous n'avez besoin que de la prise en charge des outils. Utilisez les utilitaires MCP lorsque vous avez besoin de serveurs MCP locaux, de prompts, de ressources ou d'un contrôle accru sur la connexion MCP.
</Tip>

```typescript
import {
  mcpTools,
  mcpMessages,
  mcpResourceToContent,
  mcpResourceToFile
} from "@anthropic-ai/sdk/helpers/beta/mcp";
import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";

const anthropic = new Anthropic();

// Se connecter à un serveur MCP
const transport = new StdioClientTransport({ command: "mcp-server", args: [] });
const mcpClient = new Client({ name: "my-client", version: "1.0.0" });
await mcpClient.connect(transport);

// Utiliser les prompts MCP
const { messages } = await mcpClient.getPrompt({ name: "my-prompt" });
const response = await anthropic.beta.messages.create({
  model: "claude-opus-5-5",
  max_tokens: 1024,
  messages: mcpMessages(messages)
});
console.log(response.content);

// Utiliser les outils MCP avec toolRunner
const { tools } = await mcpClient.listTools();
const finalMessage = await anthropic.beta.messages.toolRunner({
  model: "claude-opus-5-5",
  max_tokens: 1024,
  messages: [{ role: "user", content: "Use the available tools" }],
  tools: mcpTools(tools, mcpClient)
});
console.log(finalMessage.content);

// Utiliser les ressources MCP comme contenu
const resource = await mcpClient.readResource({ uri: "file:///path/to/doc.txt" });
await anthropic.beta.messages.create({
  model: "claude-opus-5-5",
  max_tokens: 1024,
  messages: [
    {
      role: "user",
      content: [
        mcpResourceToContent(resource),
        { type: "text", text: "Summarize this document" }
      ]
    }
  ]
});

// Téléverser les ressources MCP en tant que fichiers
const fileResource = await mcpClient.readResource({ uri: "file:///path/to/data.json" });
await anthropic.files.upload({ file: mcpResourceToFile(fileResource) });
```

### Gestion des erreurs MCP

Les fonctions de conversion lèvent `UnsupportedMCPValueError` si une valeur MCP n'est pas prise en charge par l'API Claude (par exemple, type de contenu non pris en charge, type MIME non pris en charge, lien de ressource non HTTP/HTTPS).

## Lots de messages

Ce SDK prend en charge le [traitement par lots](https://platform.claude.com/docs/fr/build-with-claude/batch-processing) sous l'espace de noms `client.messages.batches`.

### Création d'un lot

Message Batches accepte un tableau de requêtes, où chaque objet possède un identifiant `custom_id` et exactement les mêmes `params` de requête que l'API Messages standard :

```typescript
const batch = await client.messages.batches.create({
  requests: [
    {
      custom_id: "my-first-request",
      params: {
        model: "claude-opus-5-5",
        max_tokens: 1024,
        messages: [{ role: "user", content: "Hello, world" }]
      }
    },
    {
      custom_id: "my-second-request",
      params: {
        model: "claude-opus-5-5",
        max_tokens: 1024,
        messages: [{ role: "user", content: "Hi again, friend" }]
      }
    }
  ]
});
```

### Obtention des résultats d'un lot

Une fois qu'un Message Batch a été traité, ce qui est indiqué par `.processing_status === 'ended'`, vous pouvez accéder aux résultats avec `.batches.results()`.

```typescript
const results = await client.messages.batches.results(batch.id);
for await (const entry of results) {
  if (entry.result.type === "succeeded") {
    console.log(entry.result.message.content);
  }
}
```

## Téléversement de fichiers

Les paramètres de requête correspondant à des téléversements de fichiers peuvent être transmis sous de nombreuses formes différentes :

* `File` (ou un objet ayant la même structure)
* une `Response` de `fetch` (ou un objet ayant la même structure)
* un `fs.ReadStream`
* la valeur de retour de l'utilitaire `toFile`

Définissez explicitement le type de contenu, car l'API Files ne le déduira pas pour vous :

```typescript
import fs from "node:fs";
import Anthropic, { toFile } from "@anthropic-ai/sdk";

const client = new Anthropic();

// Si vous avez accès au module Node `fs`, utilisez `fs.createReadStream()` :
await client.files.upload({
  file: await toFile(fs.createReadStream("/path/to/file"), undefined, {
    type: "application/json"
  })
});

// Ou, si vous disposez de l'API web `File`, vous pouvez passer une instance de `File` :
await client.files.upload({
  file: new File(["my bytes"], "file.txt", { type: "text/plain" })
});
// Vous pouvez également passer une `Response` de `fetch` :
await client.files.upload({
  file: await fetch("https://somesite/file")
});

// Ou un `Buffer` / `Uint8Array`
await client.files.upload({
  file: await toFile(Buffer.from("my bytes"), "file", { type: "text/plain" })
});
await client.files.upload({
  file: await toFile(new Uint8Array([0, 1, 2]), "file", { type: "text/plain" })
});
```

## Gestion des erreurs

Lorsque la bibliothèque ne parvient pas à se connecter à l'API, ou si l'API renvoie un code de statut d'échec (c'est-à-dire une réponse 4xx ou 5xx), une sous-classe de `APIError` est levée :

```typescript
const message = await client.messages
  .create({
    max_tokens: 1024,
    messages: [{ role: "user", content: "Hello, Claude" }],
    model: "claude-opus-5-5"
  })
  .catch(async (err) => {
    if (err instanceof Anthropic.APIError) {
      console.log(err.status); // 400
      console.log(err.name); // BadRequestError
      console.log(err.headers); // {server: 'nginx', ...}
    } else {
      throw err;
    }
  });
```

Les codes d'erreur sont les suivants :

| Code de statut | Type d'erreur              |
| -------------- | -------------------------- |
| 400            | `BadRequestError`          |
| 401            | `AuthenticationError`      |
| 403            | `PermissionDeniedError`    |
| 404            | `NotFoundError`            |
| 409            | `ConflictError`            |
| 422            | `UnprocessableEntityError` |
| 429            | `RateLimitError`           |
| >=500          | `InternalServerError`      |
| N/A            | `APIConnectionError`       |

## Identifiants de requête

> Pour plus d'informations sur le débogage des requêtes, consultez [Identifiant de requête](https://platform.claude.com/docs/fr/api/errors#request-id).

Toutes les réponses objet du SDK fournissent une propriété `_request_id`, ajoutée à partir de l'en-tête de réponse `request-id`, afin que vous puissiez rapidement journaliser les requêtes en échec et les signaler à Anthropic.

```typescript
const message = await client.messages.create({
  max_tokens: 1024,
  messages: [{ role: "user", content: "Hello, Claude" }],
  model: "claude-opus-5-5"
});
console.log(message._request_id); // req_018EeWyXxfu5pfWkrYcMdjWG
```

## Nouvelles tentatives

Certaines erreurs font automatiquement l'objet de 2 nouvelles tentatives par défaut, avec un court délai exponentiel. Les erreurs de connexion (par exemple, en raison d'un problème de connectivité réseau), 408 Request Timeout, 409 Conflict, 429 Rate Limit et les erreurs internes >=500 font toutes l'objet de nouvelles tentatives par défaut.

Vous pouvez utiliser l'option `maxRetries` pour configurer ou désactiver ce comportement :

```typescript
// Configurez la valeur par défaut pour toutes les requêtes :
const client = new Anthropic({
  maxRetries: 0 // default is 2
});

// Ou configurez-la par requête :
await client.messages.create(
  {
    max_tokens: 1024,
    messages: [{ role: "user", content: "Hello, Claude" }],
    model: "claude-opus-5-5"
  },
  { maxRetries: 5 }
);
```

## Délais d'expiration

Par défaut, les requêtes expirent après 10 minutes. Cependant, si vous avez spécifié une valeur `max_tokens` élevée et que vous n'utilisez *pas* le streaming, le délai d'expiration par défaut sera calculé dynamiquement à l'aide de la formule :

```typescript
const minimum = 10 * 60;
const calculated = (60 * 60 * maxTokens) / 128_000;
return calculated < minimum ? minimum * 1000 : calculated * 1000;
```

ce qui donnera un délai d'expiration pouvant aller jusqu'à 60 minutes, proportionnel au paramètre `max_tokens`, sauf s'il est remplacé au niveau de la requête ou du client.

Vous pouvez configurer cela avec une option `timeout` :

```typescript
// Configurez la valeur par défaut pour toutes les requêtes :
const client = new Anthropic({
  timeout: 20 * 1000 // 20 seconds (default is 10 minutes)
});

// Remplacez-la pour chaque requête :
await client.messages.create(
  {
    max_tokens: 1024,
    messages: [{ role: "user", content: "Hello, Claude" }],
    model: "claude-opus-5-5"
  },
  { timeout: 5 * 1000 }
);
```

En cas d'expiration, une `APIConnectionTimeoutError` est levée.

Notez que les requêtes qui expirent font l'objet de [deux nouvelles tentatives par défaut](https://platform.claude.com/docs/fr/cli-sdks-libraries/sdks/typescript#retries).

## Requêtes longues

<Warning>
  Envisagez d'utiliser l'[API Messages](https://platform.claude.com/docs/fr/cli-sdks-libraries/sdks/typescript#streaming-responses) en streaming pour les requêtes de longue durée.
</Warning>

Évitez de définir une valeur `max_tokens` élevée sans utiliser le streaming. Certains réseaux peuvent interrompre les connexions inactives après un certain temps, ce qui peut entraîner l'échec de la requête ou son [expiration](https://platform.claude.com/docs/fr/cli-sdks-libraries/sdks/typescript#timeouts) sans recevoir de réponse d'Anthropic.

Ce SDK lève également une erreur si une requête sans streaming est censée durer plus d'environ 10 minutes. Transmettre `stream: true` ou [remplacer](https://platform.claude.com/docs/fr/cli-sdks-libraries/sdks/typescript#timeouts) l'option `timeout` au niveau du client ou de la requête désactive cette erreur.

Une latence de requête attendue supérieure au [délai d'expiration](https://platform.claude.com/docs/fr/cli-sdks-libraries/sdks/typescript#timeouts) pour une requête sans streaming entraînera la fermeture de la connexion par le client et une nouvelle tentative sans réception de réponse.

Lorsque l'implémentation de `fetch` le permet, le SDK définit une option [TCP socket keep-alive](https://tldp.org/HOWTO/TCP-Keepalive-HOWTO/overview.html) afin de réduire l'impact des délais d'expiration des connexions inactives sur certains réseaux. Ce comportement peut être [remplacé](https://platform.claude.com/docs/fr/cli-sdks-libraries/sdks/typescript#configuring-proxies) en configurant un proxy personnalisé.

## Pagination automatique

Les méthodes de liste de l'API Claude sont paginées. Vous pouvez utiliser la syntaxe `for await ... of` pour parcourir les éléments de toutes les pages :

```typescript
async function fetchAllMessageBatches() {
  const allMessageBatches = [];
  // Récupère automatiquement des pages supplémentaires si nécessaire.
  for await (const messageBatch of client.messages.batches.list({ limit: 20 })) {
    allMessageBatches.push(messageBatch);
  }
  return allMessageBatches;
}
```

Vous pouvez également demander une seule page à la fois :

```typescript
let page = await client.messages.batches.list({ limit: 20 });
for (const messageBatch of page.data) {
  console.log(messageBatch);
}

// Des méthodes pratiques sont fournies pour paginer manuellement :
while (page.hasNextPage()) {
  page = await page.getNextPage();
  // ...
}
```

## En-têtes par défaut

Le SDK envoie automatiquement l'en-tête `anthropic-version` défini sur la version de l'API correspondant à cette version majeure du SDK (consultez [Versionnage sémantique](https://platform.claude.com/docs/fr/cli-sdks-libraries/sdks/typescript#semantic-versioning)).

Si nécessaire, vous pouvez le remplacer en définissant des en-têtes par défaut pour chaque requête.

Sachez que cela peut entraîner des types incorrects et d'autres comportements inattendus ou indéfinis dans le SDK.

```typescript
const client = new Anthropic();

const message = await client.messages.create(
  {
    max_tokens: 1024,
    messages: [{ role: "user", content: "Hello, Claude" }],
    model: "claude-opus-5-5"
  },
  { headers: { "anthropic-version": "My-Custom-Value" } }
);
```

## Utilisation avancée

### Accès aux données brutes de Response (par exemple, les en-têtes)

La `Response` « brute » renvoyée par `fetch()` est accessible via la méthode `.asResponse()` du type `APIPromise` que renvoient toutes les méthodes. Cette méthode retourne dès que les en-têtes d'une réponse réussie sont reçus et ne consomme pas le corps de la réponse, vous êtes donc libre d'écrire une logique d'analyse ou de streaming personnalisée.

Vous pouvez également utiliser la méthode `.withResponse()` pour obtenir la `Response` brute ainsi que les données analysées. Contrairement à `.asResponse()`, cette méthode consomme le corps et retourne une fois celui-ci analysé.

```typescript
const client = new Anthropic();

const response = await client.messages
  .create({
    max_tokens: 1024,
    messages: [{ role: "user", content: "Hello, Claude" }],
    model: "claude-opus-5-5"
  })
  .asResponse();
console.log(response.headers.get("X-My-Header"));
console.log(response.statusText); // access the underlying Response object

const { data: message, response: raw } = await client.messages
  .create({
    max_tokens: 1024,
    messages: [{ role: "user", content: "Hello, Claude" }],
    model: "claude-opus-5-5"
  })
  .withResponse();
console.log(raw.headers.get("X-My-Header"));
console.log(message.content);
```

### Journalisation

<Warning>
  Tous les messages de journal sont destinés uniquement au débogage. Le format et le contenu des messages de journal peuvent changer d'une version à l'autre.
</Warning>

#### Niveaux de journalisation

Vous pouvez configurer le niveau de journalisation de deux manières :

1. Via la variable d'environnement `ANTHROPIC_LOG`
2. À l'aide de l'option client `logLevel` (remplace la variable d'environnement si elle est définie)

```typescript
const client = new Anthropic({
  logLevel: "debug" // Show all log messages
});
```

Niveaux de journalisation disponibles, du plus au moins verbeux :

* `'debug'` - Affiche les messages de débogage, les informations, les avertissements et les erreurs
* `'info'` - Affiche les messages d'information, les avertissements et les erreurs
* `'warn'` - Affiche les avertissements et les erreurs (par défaut)
* `'error'` - Affiche uniquement les erreurs
* `'off'` - Désactive toute journalisation

Au niveau `'debug'`, toutes les requêtes et réponses HTTP sont journalisées, y compris les en-têtes et les corps. Certains en-têtes liés à l'authentification sont masqués, mais des données sensibles dans les corps de requête et de réponse peuvent rester visibles.

#### Journaliseur personnalisé

Par défaut, cette bibliothèque journalise vers `globalThis.console`. Vous pouvez également fournir un journaliseur personnalisé. La plupart des bibliothèques de journalisation sont prises en charge, notamment [pino](https://www.npmjs.com/package/pino), [winston](https://www.npmjs.com/package/winston), [bunyan](https://www.npmjs.com/package/bunyan), [consola](https://www.npmjs.com/package/consola), [signale](https://www.npmjs.com/package/signale) et [@std/log](https://jsr.io/@std/log). Si votre journaliseur ne fonctionne pas, ouvrez une issue.

Lorsque vous fournissez un journaliseur personnalisé, l'option `logLevel` contrôle toujours les messages émis ; les messages inférieurs au niveau configuré ne seront pas envoyés à votre journaliseur.

```typescript
import pino from "pino";

const logger = pino();

const client = new Anthropic({
  logger: logger.child({ name: "Anthropic" }),
  logLevel: "debug" // Send all messages to pino, allowing it to filter
});
```

### Traçage OpenTelemetry

Lorsque votre application enregistre un tracer provider OpenTelemetry, le SDK émet un span pour chaque requête qu'il envoie. Pour envoyer les spans à votre plateforme d'observabilité, consultez [Configurer OpenTelemetry avec le SDK Claude](https://platform.claude.com/docs/fr/manage-claude/opentelemetry/sdk).

### Effectuer des requêtes personnalisées/non documentées

Cette bibliothèque est typée pour un accès pratique à l'API documentée. Si vous devez accéder à des endpoints, paramètres ou propriétés de réponse non documentés, la bibliothèque peut tout de même être utilisée.

#### Endpoints non documentés

Pour effectuer des requêtes vers des endpoints non documentés, vous pouvez utiliser `client.get`, `client.post` et d'autres verbes HTTP. Les options du client, telles que les nouvelles tentatives, sont respectées lors de ces requêtes.

```typescript
await client.post("/some/path", {
  body: { some_prop: "foo" },
  query: { some_query_arg: "bar" }
});
```

#### Paramètres de requête non documentés

Pour effectuer des requêtes avec des paramètres non documentés, vous pouvez utiliser `// @ts-expect-error` sur le paramètre non documenté. Cette bibliothèque ne vérifie pas à l'exécution que la requête correspond au type, donc toutes les valeurs supplémentaires que vous envoyez seront transmises telles quelles.

```typescript
client.messages.create({
  // ...
  // @ts-expect-error baz is not yet public
  baz: "undocumented option"
});
```

Pour les requêtes utilisant le verbe `GET`, tous les paramètres supplémentaires seront placés dans la query ; toutes les autres requêtes enverront le paramètre supplémentaire dans le corps.

Si vous souhaitez envoyer explicitement un argument supplémentaire, vous pouvez le faire avec les options de requête `query`, `body` et `headers`.

#### Propriétés de réponse non documentées

Pour accéder à des propriétés de réponse non documentées, vous pouvez accéder à l'objet de réponse avec `// @ts-expect-error` sur l'objet de réponse, ou convertir l'objet de réponse vers le type requis. Comme pour les paramètres de requête, le SDK ne valide ni ne supprime les propriétés supplémentaires de la réponse de l'API.

### Personnalisation du client fetch

Par défaut, cette bibliothèque s'attend à ce qu'une fonction `fetch` globale soit définie.

Si vous souhaitez utiliser une autre fonction `fetch`, vous pouvez soit utiliser un polyfill pour la fonction globale :

```typescript
import fetch from "my-fetch";

globalThis.fetch = fetch;
```

Soit la transmettre au client :

```typescript
import fetch from "my-fetch";

const client = new Anthropic({ fetch });
```

### Options de fetch

Si vous souhaitez définir des options `fetch` personnalisées sans remplacer la fonction `fetch`, vous pouvez fournir un objet `fetchOptions` lors de la création du client ou de l'envoi d'une requête. (Les options spécifiques à la requête remplacent les options du client.)

```typescript
const client = new Anthropic({
  fetchOptions: {
    // Options `RequestInit`
  }
});
```

### Configuration des proxys

Pour modifier le comportement du proxy, vous pouvez fournir des `fetchOptions` personnalisées qui ajoutent aux requêtes des options de proxy spécifiques à l'environnement d'exécution :

<Tabs>
  <Tab title="Node.js">
    ```typescript
    import * as undici from "undici";

    const proxyAgent = new undici.ProxyAgent("http://localhost:8888");
    const client = new Anthropic({
      fetchOptions: {
        dispatcher: proxyAgent
      }
    });
    ```
  </Tab>

  <Tab title="Bun">
    ```typescript
    const client = new Anthropic({
      fetchOptions: {
        proxy: "http://localhost:8888"
      }
    });
    ```
  </Tab>

  <Tab title="Deno">
    ```typescript
    import Anthropic from "npm:@anthropic-ai/sdk";

    const httpClient = Deno.createHttpClient({ proxy: { url: "http://localhost:8888" } });
    const client = new Anthropic({
      fetchOptions: {
        client: httpClient
      }
    });
    ```
  </Tab>
</Tabs>

## Fonctionnalités bêta

Les fonctionnalités bêta sont disponibles avant la publication générale afin de recueillir des retours précoces et de tester de nouvelles fonctionnalités. Vous pouvez vérifier la disponibilité de toutes les capacités et de tous les outils de Claude dans la [Vue d'ensemble des fonctionnalités](https://platform.claude.com/docs/fr/build-with-claude/overview).

Vous pouvez accéder à la plupart des fonctionnalités bêta de l'API via la propriété `beta` du client. Pour activer une fonctionnalité bêta particulière, vous devez ajouter l'[en-tête bêta](https://platform.claude.com/docs/fr/api/beta-headers) approprié au champ `betas` lors de la création d'un message.

Par exemple, pour activer l'[édition du contexte](https://platform.claude.com/docs/fr/build-with-claude/context-editing) :

```typescript
const client = new Anthropic();
const response = await client.beta.messages.create({
  model: "claude-opus-5-5",
  max_tokens: 1024,
  messages: [{ role: "user", content: "Hello, Claude" }],
  betas: ["context-management-2025-06-27"]
});
```

## Prise en charge des environnements d'exécution

<Accordion title="Utilisation dans le navigateur">
  Activer l'option `dangerouslyAllowBrowser` peut être dangereux, car cela expose vos identifiants API secrets dans le code côté client. Les navigateurs web sont intrinsèquement moins sécurisés que les environnements serveur. Tout utilisateur ayant accès au navigateur peut potentiellement inspecter, extraire et utiliser abusivement ces identifiants. Cela pourrait entraîner un accès non autorisé à l'aide de vos identifiants et potentiellement compromettre des données ou des fonctionnalités sensibles.

  **Quand cela pourrait-il ne pas être dangereux ?**

  Dans certains scénarios, l'activation de la prise en charge des navigateurs peut ne pas présenter de risques significatifs :

  * **Outils internes :** si l'application est utilisée uniquement dans un environnement interne contrôlé où les utilisateurs sont de confiance, le risque d'exposition des identifiants peut être atténué.
  * **Développement ou débogage :** activer temporairement cette fonctionnalité peut être acceptable, à condition que les identifiants aient une courte durée de vie, ne soient pas également utilisés dans des environnements de production, ou fassent l'objet d'une rotation fréquente.
</Accordion>

## Intégrations de plateformes

<Note>
  Pour des guides détaillés de configuration des plateformes avec des exemples de code, consultez :

  * [Amazon Bedrock](https://platform.claude.com/docs/fr/build-with-claude/claude-in-amazon-bedrock)
  * [Amazon Bedrock (Opus 4.6 et versions antérieures)](https://platform.claude.com/docs/fr/build-with-claude/claude-on-amazon-bedrock-legacy)
  * [Claude Platform on AWS](https://platform.claude.com/docs/fr/build-with-claude/claude-platform-on-aws)
  * [Claude Models on Google Cloud (Google managed)](https://platform.claude.com/docs/fr/build-with-claude/claude-models-on-google-cloud/google-managed)
  * [Microsoft Foundry](https://platform.claude.com/docs/fr/build-with-claude/claude-in-microsoft-foundry)

  Consultez également [Claude Models on Google Cloud (Anthropic managed)](https://platform.claude.com/docs/fr/build-with-claude/claude-models-on-google-cloud/anthropic-managed).
</Note>

Le SDK TypeScript prend en charge les plateformes suivantes :

* **Agent Platform :** `npm install @anthropic-ai/vertex-sdk` : fournit le client `AnthropicVertex`
* **Bedrock :** `npm install @anthropic-ai/bedrock-sdk` : fournit le client `AnthropicBedrockMantle`, ainsi que `AnthropicBedrock` pour le chemin `bedrock-runtime`
* **Claude Platform on AWS :** `npm install @anthropic-ai/aws-sdk` : fournit le client `AnthropicAws`. Transmettez `workspaceId` au constructeur ou définissez la variable d'environnement `ANTHROPIC_AWS_WORKSPACE_ID`. Disponible en bêta.
* **Foundry :** `npm install @anthropic-ai/foundry-sdk` : fournit le client `AnthropicFoundry`

Utilisez `AnthropicBedrockMantle` pour les nouveaux projets ; `AnthropicBedrock` reste disponible pour les applications existantes utilisant l'API Bedrock `InvokeModel`.

Le SDK TypeScript prend également en charge Claude Models on Google Cloud (Anthropic managed) via le client `AnthropicGoogleCloud`. Ce client est en version bêta. Pour l'installer, exécutez `npm install @anthropic-ai/google-cloud-sdk`. Transmettez `workspaceId` au constructeur ou définissez la variable d'environnement `ANTHROPIC_GOOGLE_CLOUD_WORKSPACE_ID`. Consultez [Résolution du projet, de l'emplacement et de l'espace de travail](https://platform.claude.com/docs/fr/build-with-claude/claude-models-on-google-cloud/anthropic-managed#project-location-and-workspace-resolution) pour savoir comment le client résout l'ID de l'espace de travail.

## Versionnage sémantique

Chaque version majeure de ce SDK envoie par défaut une version de l'API dans l'en-tête `anthropic-version`, et une nouvelle version majeure accompagne chaque nouvelle version de l'API. La première version majeure qui envoie `2026-10-21` est la 1.0.0 ; consultez [Migration vers la version 2026-10-21 de l'API](https://platform.claude.com/docs/fr/api/migration-2026-10-21#upgrade).

Ce paquet suit généralement les conventions [SemVer](https://semver.org/spec/v2.0.0.html), bien que certaines modifications rétro-incompatibles puissent être publiées sous forme de versions mineures :

1. Les modifications qui n'affectent que les types statiques, sans casser le comportement à l'exécution.
2. Les modifications des éléments internes de la bibliothèque qui sont techniquement publics mais ne sont ni destinés ni documentés pour un usage externe.
3. Les modifications qui ne devraient pas avoir d'impact sur la grande majorité des utilisateurs en pratique.

La rétrocompatibilité est prise au sérieux afin que vous puissiez compter sur une expérience de mise à niveau fluide.

## Questions fréquentes

Consultez le [dépôt GitHub](https://github.com/anthropics/anthropic-sdk-typescript) pour les FAQ, les issues et le support communautaire.

## Ressources supplémentaires

* [Dépôt GitHub](https://github.com/anthropics/anthropic-sdk-typescript)
* [Référence de l'API](https://platform.claude.com/docs/fr/api/overview)
* [Streaming de messages](https://platform.claude.com/docs/fr/build-with-claude/streaming)
* [Utilisation d'outils avec Claude](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/overview)