SDK TypeScript

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

Installation

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).
• 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). 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.

Utilisation

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. Si votre clé API est une clé de compte personnel ou de compte de service 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 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 :

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 :

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).

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 :

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. 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.

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 :

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.

Utilitaires MCP

Ce SDK fournit des utilitaires pour l'intégration avec les serveurs Model Context Protocol (MCP). 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.

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 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 :

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().

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 :

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 :

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 :

Identifiants de requête

Pour plus d'informations sur le débogage des requêtes, consultez Identifiant de requête.

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.

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 :

// 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 :

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 :

// 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.

Requêtes longues

É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 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 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 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 afin de réduire l'impact des délais d'expiration des connexions inactives sur certains réseaux. Ce comportement peut être remplacé 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 :

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 :

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).

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.

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é.

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

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)

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, winston, bunyan, consola, signale et @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.

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.

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.

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.

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 :

import fetch from "my-fetch";

globalThis.fetch = fetch;

Soit la transmettre au client :

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.)

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 :

import * as undici from "undici";

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

const client = new Anthropic({
  fetchOptions: {
    proxy: "http://localhost:8888"
  }
});

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

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

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.

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 approprié au champ betas lors de la création d'un message.

Par exemple, pour activer l'édition du contexte :

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

Intégrations de plateformes

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 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.

Ce paquet suit généralement les conventions SemVer, 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 pour les FAQ, les issues et le support communautaire.

Ressources supplémentaires

• Dépôt GitHub
• Référence de l'API
• Streaming de messages
• Utilisation d'outils avec Claude