SDK PHP

La bibliothèque PHP d'Anthropic fournit un accès pratique à l'API Claude depuis toute application PHP 8.1.0+.

Installation

Le SDK utilise PSR-18 pour HTTP et détecte automatiquement tout client PSR-18 installé. Guzzle est recommandé, car le SDK le configure pour le « streaming » (streaming) sans configuration supplémentaire :

composer require "anthropic-ai/sdk" "guzzlehttp/guzzle:^7"

Prérequis

PHP 8.1.0 ou supérieur.

Utilisation

Cette bibliothèque utilise des paramètres nommés pour spécifier les arguments optionnels. Les paramètres ayant une valeur par défaut doivent être définis par leur nom.

$client = new Client();

$message = $client->messages->create(
  maxTokens: 1024,
  messages: [['role' => 'user', 'content' => 'Hello, Claude']],
  model: 'claude-opus-5-5',
);

$textBlock = array_find($message->content, static fn ($block): bool => $block->type === 'text');
echo $textBlock->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.

Objets valeur

Il est recommandé d'utiliser le constructeur statique with Base64ImageSource::with(data: "U3RhaW5sZXNzIHJvY2tz", ...) et des paramètres nommés pour initialiser les objets valeur.

Cependant, des builders sont également fournis : (new Base64ImageSource)->withData("U3RhaW5sZXNzIHJvY2tz").

Streaming

Le SDK prend en charge le streaming des réponses à l'aide des « Server-Sent Events » (événements envoyés par le serveur), ou SSE.

$client = new Client();

$stream = $client->messages->createStream(
  maxTokens: 1024,
  messages: [['role' => 'user', 'content' => 'Hello, Claude']],
  model: 'claude-opus-5-5',
);

foreach ($stream as $event) {
  echo $event->type . PHP_EOL;
}

Le streaming nécessite un client HTTP qui renvoie le corps de la réponse de manière incrémentale. Lorsque Guzzle est le client PSR-18 détecté, le SDK le configure automatiquement pour le streaming. Avec un client qui met en mémoire tampon, la boucle foreach produit tous les événements d'un coup lorsque la réponse est terminée, au lieu de le faire de manière incrémentale ; si vous observez ce symptôme, installez Guzzle ou fournissez un client PSR-18 compatible avec le streaming via l'option de requête streamingTransporter :

$client = new Client(
  requestOptions: RequestOptions::with(streamingTransporter: $myStreamingClient),
);

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 Anthropic\Core\Exceptions\APIException est levée :

<?php
// ...
use Anthropic\Core\Exceptions\APIConnectionException;
use Anthropic\Core\Exceptions\APIStatusException;
use Anthropic\Core\Exceptions\RateLimitException;
// ...
try {
  $message = $client->messages->create(
    maxTokens: 1024,
    messages: [['role' => 'user', 'content' => 'Hello, Claude']],
    model: 'claude-opus-5-5',
  );
} catch (APIConnectionException $e) {
  echo "The server could not be reached", PHP_EOL;
  echo $e->getPrevious()?->getMessage(), PHP_EOL;
} catch (RateLimitException $_) {
  echo "A 429 status code was received; we should back off a bit.", PHP_EOL;
} catch (APIStatusException $e) {
  echo "Another non-200-range status code was received", PHP_EOL;
  echo $e->getMessage();
}

Les codes d'erreur sont les suivants :

Nouvelles tentatives

Certaines erreurs font automatiquement l'objet de deux nouvelles tentatives par défaut, avec un court délai d'attente exponentiel (backoff).

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

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

use Anthropic\RequestOptions;
// ...
// Configurez la valeur par défaut pour toutes les requêtes :
$client = new Client(requestOptions: RequestOptions::with(maxRetries: 0));

// Ou configurez-la par requête :
$result = $client->messages->create(
  maxTokens: 1024,
  messages: [['role' => 'user', 'content' => 'Hello, Claude']],
  model: 'claude-opus-5-5',
  requestOptions: RequestOptions::with(maxRetries: 5),
);

Pagination

Les méthodes de liste de l'API Claude sont paginées.

Cette bibliothèque fournit des itérateurs à pagination automatique avec chaque réponse de liste, de sorte que vous n'avez pas à demander manuellement les pages successives :

$client = new Client();

$page = $client->beta->messages->batches->list(limit: 20);

// récupère les éléments de la page actuelle
foreach ($page->getItems() as $item) {
  echo $item->id, PHP_EOL;
}
// effectue des requêtes réseau supplémentaires pour récupérer les éléments de toutes les pages, à partir de la page actuelle incluse
// ...
foreach ($page->pagingEachItem() as $item) {
  echo $item->id, PHP_EOL;
// ...
}

Utilisation avancée

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.

Propriétés non documentées

Vous pouvez envoyer des paramètres non documentés à n'importe quel endpoint et lire des propriétés de réponse non documentées, comme suit :

<?php
// ...
use Anthropic\RequestOptions;
// ...
$message = $client->messages->create(
  maxTokens: 1024,
  messages: [['role' => 'user', 'content' => 'Hello, Claude']],
  model: 'claude-opus-5-5',
  requestOptions: RequestOptions::with(
    extraQueryParams: ['my_query_parameter' => 'value'],
    extraBodyParams: ['my_body_parameter' => 'value'],
    extraHeaders: ['my-header' => 'value'],
  ),
);

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

Si vous souhaitez envoyer explicitement un paramètre supplémentaire, vous pouvez le faire avec les options extraQueryParams, extraBodyParams et extraHeaders sous RequestOptions::with() lors de l'envoi d'une requête, comme illustré dans l'exemple précédent.

Endpoints non documentés

Pour envoyer des requêtes à des endpoints non documentés tout en conservant les avantages de l'authentification, des nouvelles tentatives et des autres fonctionnalités du client, vous pouvez effectuer des requêtes à l'aide de client->request, comme suit :

$client = new Client();

$response = $client->request(
  method: "post",
  path: '/undocumented/endpoint',
  query: ['dog' => 'woof'],
  headers: ['useful-header' => 'interesting-value'],
  body: ['hello' => 'world']
);

Intégrations de plateformes

Le SDK PHP prend en charge les plateformes suivantes :

• Agent Platform : Anthropic\Vertex\Client. Utilisez ::fromEnvironment().
• Bedrock : Anthropic\Bedrock\MantleClient. Utilisez new MantleClient(awsRegion: ...).
• Bedrock (ancienne version) : Anthropic\Bedrock\Client. Utilisez ::fromEnvironment() ou ::withCredentials().
• Claude Platform sur AWS : Anthropic\Aws\Client (nécessite aws/aws-sdk-php comme dépendance optionnelle). Utilisez new Anthropic\Aws\Client(workspaceId: ...) ou définissez ANTHROPIC_AWS_WORKSPACE_ID. Disponible en version bêta.
• Foundry : Anthropic\Foundry\Client. Utilisez ::withCredentials().

Utilisez MantleClient pour les nouveaux projets ; Anthropic\Bedrock\Client est conservé pour les applications existantes utilisant l'API Bedrock InvokeModel.

Le SDK PHP prend également en charge Claude Models on Google Cloud (Anthropic managed) via Anthropic\GoogleCloud\Client. Ce client est en version bêta. Anthropic\GoogleCloud\Client nécessite google/auth comme dépendance optionnelle. Utilisez new Anthropic\GoogleCloud\Client(workspaceId: ...) 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.

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 Passer à la version 2026-10-21.

Ce package suit les conventions SemVer.

Ce package considère les améliorations des définitions de types PHPDoc (hors exécution) comme des changements non cassants.

Ressources supplémentaires

• Dépôt GitHub
• Packagist
• Référence de l'API
• Streaming des messages