---
title: Référence OAuth
url: https://platform.claude.com/docs/fr/manage-claude/oauth-apps/oauth-reference
description: Points de terminaison, authentification du client, paramètres de requête, portées, réponses de jeton, révocation, durées de vie, règles des URI de redirection et erreurs.
---

<Warning>
  Claude Platform OAuth est un Beta Service : un logiciel en préversion fourni dans le cadre de votre accord avec Anthropic, tel que les [Conditions commerciales d’utilisation](https://www.anthropic.com/legal/commercial-terms), et les [Conditions spécifiques aux services](https://www.anthropic.com/legal/service-specific-terms). Les points de terminaison, les paramètres et le comportement peuvent changer pendant la bêta. Il peut ne pas convenir à une utilisation en production.
</Warning>

Cette page rassemble les points de terminaison, les paramètres, les règles de validation et les correspondances d’erreurs pour [Claude Platform OAuth](https://platform.claude.com/docs/fr/manage-claude/oauth-apps/overview). Pour un guide pas à pas, consultez [Linked billing](https://platform.claude.com/docs/fr/manage-claude/oauth-apps/organization-billing-connections).

## Points de terminaison

| Point de terminaison                                                                              | URL                                                                                |
| ------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------- |
| Émetteur                                                                                          | `https://identity.anthropic.com/users`                                             |
| Document de découverte                                                                            | `https://identity.anthropic.com/users/.well-known/openid-configuration`            |
| Clés de signature (JWKS)                                                                          | Le `jwks_uri` dans le document de découverte, hébergé sur `identity.anthropic.com` |
| Point de terminaison d’autorisation (page de connexion et de consentement)                        | `https://auth.claude.com/oauth/authorize`                                          |
| Point de terminaison de « pushed authorization request » (requête d’autorisation poussée), ou PAR | `https://auth.claude.com/v1/oauth/par`                                             |
| Point de terminaison de jeton                                                                     | `https://auth.claude.com/v1/oauth/token`                                           |
| Point de terminaison de révocation                                                                | `https://auth.claude.com/v1/oauth/revoke`                                          |
| Claude API (profils utilisateur et requêtes facturées à un client)                                | `https://api.anthropic.com`                                                        |

Lisez les clés de signature depuis le document de découverte plutôt que de les coder en dur. Le document de découverte ne répertorie ni le point de terminaison PAR ni le point de terminaison de révocation ; utilisez donc les URL de ce tableau.

## Valeurs du document de découverte

| Champ                                   | Valeur                                           |
| --------------------------------------- | ------------------------------------------------ |
| `issuer`                                | `https://identity.anthropic.com/users`           |
| `authorization_endpoint`                | `https://auth.claude.com/oauth/authorize`        |
| `token_endpoint`                        | `https://auth.claude.com/v1/oauth/token`         |
| `jwks_uri`                              | `https://identity.anthropic.com/users/jwks.json` |
| `response_types_supported`              | `code`                                           |
| `grant_types_supported`                 | `authorization_code`, `refresh_token`            |
| `code_challenge_methods_supported`      | `S256`                                           |
| `token_endpoint_auth_methods_supported` | `private_key_jwt`                                |
| `id_token_signing_alg_values_supported` | `ES256`                                          |
| `scopes_supported`                      | `openid`, `email`                                |
| `subject_types_supported`               | `public`, `pairwise`                             |

`auth.claude.com` renvoie un jeton d’actualisation pour Linked billing uniquement lorsque le client a approuvé `offline_access` conjointement avec `billing:attribution` : consultez [Jetons OAuth pour une connexion de facturation](https://platform.claude.com/docs/fr/manage-claude/oauth-apps/oauth-reference#oauth-tokens-for-a-billing-connection).

## Authentification du client

`auth.claude.com` authentifie un client confidentiel avec la méthode `private_key_jwt` ([RFC 7523](https://www.rfc-editor.org/rfc/rfc7523)). Envoyez ces paramètres dans chaque requête vers le point de terminaison PAR, le point de terminaison de jeton et le point de terminaison de révocation. N’envoyez jamais d’identifiants dans la chaîne de requête d’une URL : `auth.claude.com` les rejette.

| Paramètre               | Valeur                                                                                                                                                                                                                           |
| ----------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `client_id`             | L’ID client de votre application OAuth                                                                                                                                                                                           |
| `client_assertion_type` | `urn:ietf:params:oauth:client-assertion-type:jwt-bearer`                                                                                                                                                                         |
| `client_assertion`      | Un JWT émis par votre fournisseur d’identité avec les revendications indiquées dans [Revendications de l’assertion client](https://platform.claude.com/docs/fr/manage-claude/oauth-apps/oauth-reference#client-assertion-claims) |

### Revendications de l’assertion client

Une « client assertion » (assertion client) doit contenir toutes les revendications suivantes, et son en-tête doit contenir le `kid` d’une clé de votre JWKS.

| Revendication | Exigence                                                                                                                                                                                                |
| ------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `iss`         | L’URL de l’émetteur de votre fournisseur d’identité, exactement telle qu’enregistrée via [Workload Identity Federation](https://platform.claude.com/docs/fr/manage-claude/workload-identity-federation) |
| `sub`         | Une valeur qui correspond au modèle de sujet défini dans les paramètres d’authentification client de votre application, si vous en avez défini un                                                       |
| `aud`         | Exactement une audience : la valeur définie dans les paramètres d’authentification client de votre application. `auth.claude.com` rejette une assertion qui répertorie plus d’une audience.             |
| `iat`         | L’heure à laquelle votre fournisseur d’identité a émis le JWT                                                                                                                                           |
| `exp`         | L’heure d’expiration, au plus 1 heure après `iat`. Utilisez une durée de vie plus courte lorsque c’est possible : toute personne qui intercepte une assertion peut l’utiliser jusqu’à son expiration.   |

Exemple de charge utile d’assertion :

```json
{
  "iss": "https://idp.example.com",
  "sub": "workload:prod:claude-integration-backend",
  "aud": "YOUR_CONFIGURED_AUDIENCE",
  "iat": 1791230000,
  "exp": 1791230300
}
```

Rendez le modèle de sujet et les conditions de revendications aussi restrictifs que votre back-end le permet. `auth.claude.com` accepte tout JWT de votre fournisseur d’identité qui y correspond comme authentification de votre application.

## Paramètres de la requête d’autorisation

Envoyez ces paramètres, à l’exception de `request_uri`, dans le corps JSON d’une requête d’autorisation poussée.

| Paramètre                | Linked billing | Description                                                                                                                                                                                                 |
| ------------------------ | -------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `response_type`          | Obligatoire    | La valeur `code`                                                                                                                                                                                            |
| `client_id`              | Obligatoire    | L’ID client de votre application OAuth                                                                                                                                                                      |
| `redirect_uri`           | Obligatoire    | Un URI qui correspond exactement à un URI de redirection enregistré, jusqu’à 2048 caractères                                                                                                                |
| `scope`                  | Obligatoire    | Pour une connexion de facturation, `billing:attribution` ou `billing:attribution offline_access`. Consultez [Portées](https://platform.claude.com/docs/fr/manage-claude/oauth-apps/oauth-reference#scopes). |
| `state`                  | Obligatoire    | Une valeur aléatoire à usage unique, jusqu’à 2048 caractères, que vous vérifiez lors du callback                                                                                                            |
| `code_challenge`         | Obligatoire    | `BASE64URL(SHA256(code_verifier))`, où le `code_verifier` comporte de 43 à 128 caractères                                                                                                                   |
| `code_challenge_method`  | Obligatoire    | La valeur `S256`                                                                                                                                                                                            |
| `connection_type`        | Obligatoire    | La valeur `organization_shared`. Cette valeur demande une connexion d’organisation pour la facturation.                                                                                                     |
| `connection_auth_target` | Obligatoire    | L’organisation vers laquelle les requêtes de la connexion sont acheminées. Pour Linked billing, envoyez `platform` (le propriétaire de l’application OAuth).                                                |
| `user_profile_id`        | Obligatoire    | L’ID d’un profil utilisateur actif de votre organisation qui représente le client                                                                                                                           |
| `request_uri`            | Obligatoire    | La valeur renvoyée par le point de terminaison PAR. Envoyez-la au point de terminaison d’autorisation avec `client_id` et aucun autre paramètre.                                                            |

Le point de terminaison PAR renvoie HTTP 201 avec `request_uri` et `expires_in` (600 secondes).

## Portées

| Catégorie   | Portée                    | Description                                                                                                                                                                                                                                                                                                                                                                                                                                  | Type de connexion     | Type de client |
| ----------- | ------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------- | -------------- |
| Général     | `offline_access`          | Fournit à l’application un jeton d’actualisation représentant les autres portées demandées. Sur une connexion `organization_shared`, envoyez-la uniquement conjointement avec `billing:attribution`.                                                                                                                                                                                                                                         | `organization_shared` | Confidentiel   |
| Facturation | `billing:attribution`     | Une connexion qui vous permet de facturer à l’organisation Claude d’un client les requêtes à la Claude API que ce client vous demande d’effectuer. Envoyez-la seule, ou conjointement avec `offline_access` pour obtenir également un jeton d’actualisation. Consultez [Jetons OAuth pour une connexion de facturation](https://platform.claude.com/docs/fr/manage-claude/oauth-apps/oauth-reference#oauth-tokens-for-a-billing-connection). | `organization_shared` | Confidentiel   |
| Facturation | `org:billing_attribution` | Dépréciée : utilisez `billing:attribution`.                                                                                                                                                                                                                                                                                                                                                                                                  | `organization_shared` | Confidentiel   |

## Requête et réponse de jeton

Envoyez les requêtes de jeton à `https://auth.claude.com/v1/oauth/token` avec un corps JSON.

| Paramètre                                                | Valeur                                                                                                                                      |
| -------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------- |
| `grant_type`                                             | `authorization_code`                                                                                                                        |
| `code`                                                   | Le code reçu lors du callback                                                                                                               |
| `redirect_uri`                                           | Le même `redirect_uri` que celui envoyé dans la requête d’autorisation                                                                      |
| `code_verifier`                                          | Le vérificateur de code PKCE                                                                                                                |
| `client_id`, `client_assertion_type`, `client_assertion` | Comme dans [Authentification du client](https://platform.claude.com/docs/fr/manage-claude/oauth-apps/oauth-reference#client-authentication) |

La réponse de jeton contient ces champs :

| Champ de réponse           | Linked billing                                                                                                                                         |
| -------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `access_token`             | [Le jeton d’accès de la connexion](https://platform.claude.com/docs/fr/manage-claude/oauth-apps/oauth-reference#oauth-tokens-for-a-billing-connection) |
| `token_type`               | `Bearer`                                                                                                                                               |
| `expires_in`               | Au plus `3600`                                                                                                                                         |
| `scope`                    | `workspace:inference`                                                                                                                                  |
| `connection_id`            | L’ID de connexion, par exemple `ocon_EXAMPLE`. Conservez-le.                                                                                           |
| `refresh_token`            | Renvoyé uniquement lorsque le client a approuvé `offline_access`                                                                                       |
| `refresh_token_expires_in` | Nombre de secondes avant l’expiration de `refresh_token`. Absent lorsqu’il n’y a pas de `refresh_token`.                                               |

Pour actualiser, envoyez `grant_type` défini sur `refresh_token`, votre `refresh_token` et les paramètres indiqués dans [Authentification du client](https://platform.claude.com/docs/fr/manage-claude/oauth-apps/oauth-reference#client-authentication). L’actualisation d’une connexion de facturation suit les règles indiquées dans [Jetons OAuth pour une connexion de facturation](https://platform.claude.com/docs/fr/manage-claude/oauth-apps/oauth-reference#oauth-tokens-for-a-billing-connection).

## Jetons OAuth pour une connexion de facturation

Pour une connexion de facturation, le point de terminaison de jeton renvoie le jeton d’accès de la connexion. Ce jeton s’authentifie en tant que [compte de service opérateur](https://platform.claude.com/docs/fr/manage-claude/oauth-apps/oauth-reference#terms) de votre application, dans l’espace de travail désigné par le paramètre `connection_token_workspace_id` de l’application. Sur `/v1/messages` et `/v1/chat/completions`, une requête effectuée avec ce jeton est facturée au client de cette connexion et à aucun autre. Lorsque le client a également approuvé `offline_access`, le point de terminaison de jeton renvoie aussi un jeton d’actualisation, et l’octroi `refresh_token` renouvelle les deux jetons. Pour la configuration et le guide pas à pas, consultez [Jetons OAuth pour chaque connexion](https://platform.claude.com/docs/fr/manage-claude/oauth-apps/organization-billing-connections#oauth-tokens-for-each-connection) sur la page Linked billing.

Les deux octrois acceptent les paramètres indiqués dans [Requête et réponse de jeton](https://platform.claude.com/docs/fr/manage-claude/oauth-apps/oauth-reference#token-request-and-response), avec l’[Authentification du client](https://platform.claude.com/docs/fr/manage-claude/oauth-apps/oauth-reference#client-authentication). Une actualisation ne doit pas envoyer de paramètre `scope`. La réponse de jeton contient ces champs :

| Champ de réponse           | Valeur                                                                                                      |
| -------------------------- | ----------------------------------------------------------------------------------------------------------- |
| `access_token`             | Le jeton d’accès de la connexion                                                                            |
| `token_type`               | `Bearer`                                                                                                    |
| `expires_in`               | Nombre de secondes avant l’expiration du jeton d’accès, au plus `3600`                                      |
| `scope`                    | Toujours `workspace:inference`                                                                              |
| `connection_id`            | L’ID de connexion, par exemple `ocon_EXAMPLE`. Seul l’octroi `authorization_code` le renvoie.               |
| `refresh_token`            | Le jeton d’actualisation de la connexion. Renvoyé uniquement lorsque le client a approuvé `offline_access`. |
| `refresh_token_expires_in` | Nombre de secondes avant l’expiration de `refresh_token`                                                    |

Chaque actualisation renvoie un nouveau `access_token` et un nouveau `refresh_token`. Le jeton d’actualisation que vous avez envoyé est remplacé, et le jeton d’accès précédent cesse de fonctionner en quelques minutes. Vous pouvez envoyer une fois de plus le jeton d’actualisation remplacé, dans les 30 secondes suivant l’actualisation qui l’a remplacé, afin de répéter une requête dont vous avez perdu la réponse. Cette seconde requête renvoie une autre nouvelle paire et révoque la paire de la réponse perdue : utilisez uniquement la paire la plus récente. Une troisième requête effectuée avec le jeton remplacé reçoit `invalid_grant`, tout comme une deuxième requête qui arrive après les 30 secondes. Dans les 30 secondes, une telle requête ne révoque rien. Après les 30 secondes, elle révoque tous les jetons de la connexion et met fin à la connexion. La section [Actualiser les jetons](https://platform.claude.com/docs/fr/manage-claude/oauth-apps/organization-billing-connections#refresh-the-connection) présente les règles et les erreurs d’une actualisation.

Chacun de ces événements révoque les jetons de la connexion, y compris le jeton d’accès actuel :

* Le client ou vous-même supprimez la liaison.
* Le client approuve une nouvelle requête d’autorisation avec des portées différentes pour le même profil utilisateur, et vous échangez le code de cette approbation. La nouvelle connexion remplace la précédente.
* L’espace de travail dans lequel les jetons s’exécutent est archivé.

Pour savoir comment la Claude API facture une requête effectuée avec le jeton d’accès d’une connexion, consultez [Appeler Claude avec le jeton d’accès d’une connexion](https://platform.claude.com/docs/fr/manage-claude/oauth-apps/organization-billing-connections#call-claude-with-a-connections-access-token).

## Révocation

Envoyez les requêtes de révocation à `https://auth.claude.com/v1/oauth/revoke` avec un corps JSON ou encodé en formulaire. Le point de terminaison suit la [RFC 7009](https://www.rfc-editor.org/rfc/rfc7009) et accepte également les ID de connexion et de profil utilisateur.

Envoyez les paramètres indiqués dans [Authentification du client](https://platform.claude.com/docs/fr/manage-claude/oauth-apps/oauth-reference#client-authentication) et exactement un des paramètres de ce tableau. Le `aud` de l’assertion client est la valeur définie dans les paramètres d’authentification client de votre application, et non l’URL de révocation.

| Paramètre         | Ce à quoi il met fin                                                                                                                         |
| ----------------- | -------------------------------------------------------------------------------------------------------------------------------------------- |
| `connection_id`   | L’une des connexions de votre application, indiquée sous forme d’ID `ocon_`                                                                  |
| `user_profile_id` | Toutes les connexions de votre application sur un profil utilisateur, indiqué sous forme d’ID `uprof_`                                       |
| `token`           | Pour Linked billing, envoyez plutôt `connection_id` ou `user_profile_id` : l’envoi d’un jeton d’accès peut ne pas mettre fin à la connexion. |

`auth.claude.com` accepte `token_type_hint` et l’ignore.

Le point de terminaison renvoie HTTP 200 et les ID des connexions auxquelles la requête a mis fin :

```json
{
  "revoked_connection_ids": ["ocon_EXAMPLE"]
}
```

La liste est vide si le jeton ou l’ID est inconnu ou appartient à une autre application, si la connexion a déjà pris fin, ou si la requête a mis fin à un jeton mais à aucune connexion. La réponse ne précise pas laquelle de ces causes s’applique.

Après la fin d’une connexion de facturation, la Claude API refuse les requêtes facturées à ce client, avec `user_profile_not_billable`, et les jetons OAuth de la connexion cessent de fonctionner. Ne vous fiez plus ensuite au jeton d’accès d’une connexion approuvée avec la portée dépréciée `org:billing_attribution` : il peut cesser de fonctionner immédiatement, ou fonctionner jusqu’à son expiration.

## Durées de vie

| Élément                                             | Durée de vie                                                                       |
| --------------------------------------------------- | ---------------------------------------------------------------------------------- |
| `request_uri` provenant du point de terminaison PAR | 10 minutes, usage unique                                                           |
| Code d’autorisation                                 | 5 minutes, usage unique                                                            |
| `access_token`                                      | Jusqu’à 1 heure                                                                    |
| `refresh_token`                                     | Jusqu’à 1 an à compter de l’échange du code. Une actualisation ne le prolonge pas. |

Ce sont les valeurs actuelles. Lisez `expires_in` et `refresh_token_expires_in` dans chaque réponse plutôt que de vous fier à des valeurs fixes.

## Règles des URI de redirection

* Chaque `redirect_uri` doit correspondre exactement à un URI enregistré dans votre application. `auth.claude.com` n’utilise pas de correspondance par caractère générique ni par préfixe.
* Chaque URI de redirection doit utiliser HTTPS et ne doit pas contenir de fragment. Les URI de développement local sur `localhost`, `127.0.0.1` ou `[::1]` peuvent utiliser HTTP.
* Un URI de développement local enregistré avec un astérisque comme port, tel que `http://localhost:*/callback`, correspond à n’importe quel port.
* Vous pouvez enregistrer jusqu’à 10 URI de redirection pour chaque application.
* `auth.claude.com` envoie les erreurs à votre URI de redirection uniquement lorsque le `redirect_uri` correspond à un URI enregistré. Pour tout autre `redirect_uri`, `auth.claude.com` ne redirige pas le navigateur.

## Erreurs

### Erreurs lors de la redirection

`auth.claude.com` renvoie les erreurs sous forme de paramètres de requête `error`, `error_description` et `state` sur votre URI de redirection. Il s’agit d’erreurs OAuth 2.0 standard ([RFC 6749](https://www.rfc-editor.org/rfc/rfc6749)), à l’exception de `user_profile_already_linked`, qui est spécifique à Anthropic.

| Erreur                        | Quand                                                                                                                                                                                                                                                                         | Ce qu’il faut afficher à votre utilisateur                                                                                                                                                                                                                                                                                                                                                                                                           |
| ----------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `access_denied`               | La personne a refusé, ou ne peut pas approuver cette requête. Pour une connexion de facturation, la personne doit être administrateur d’une organisation Claude.                                                                                                              | Expliquez que la connexion n’a pas abouti, et ne supposez pas que la personne a refusé. Pour une connexion de facturation, suivez [Votre URI de redirection reçoit `error=access_denied`](https://platform.claude.com/docs/fr/manage-claude/oauth-apps/organization-billing-connections#access-denied) dans le guide Linked billing, qui répertorie les causes et ce qu’il faut dire à la personne. Sinon, demandez à la personne de vous contacter. |
| `server_error`                | `auth.claude.com` n’a pas réussi à traiter la requête.                                                                                                                                                                                                                        | Demandez à l’utilisateur de réessayer.                                                                                                                                                                                                                                                                                                                                                                                                               |
| `user_profile_already_linked` | Linked billing uniquement. L’organisation du client est déjà liée à votre application via un autre profil utilisateur. Chaque organisation cliente peut avoir une seule connexion à votre application. `auth.claude.com` a déjà demandé à l’administrateur de vous contacter. | Expliquez que son organisation est déjà liée à votre application.                                                                                                                                                                                                                                                                                                                                                                                    |

Si le `request_uri` a expiré ou si vous l’avez déjà utilisé, `auth.claude.com` affiche une page d’erreur et ne redirige pas le navigateur vers votre application. Recommencez le flux avec une nouvelle requête d’autorisation poussée.

### Erreurs des points de terminaison PAR et de jeton

Ces points de terminaison renvoient un corps JSON avec `error` et `error_description`.

| Erreur                        | Quand                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| ----------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `invalid_request`             | Un paramètre obligatoire est manquant ou non valide, par exemple un `state` ou un challenge PKCE manquant, ou un `user_profile_id` qui n’est pas l’ID d’un profil utilisateur actif de votre organisation.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| `invalid_client`              | `auth.claude.com` n’a pas pu authentifier votre application : l’ID client est inconnu, ou la vérification de l’assertion client a échoué. Comparez les valeurs `iss`, `sub` et `aud` de l’assertion aux paramètres d’authentification client de votre application, et vérifiez que votre fournisseur d’identité l’a signée avec une clé de votre JWKS.                                                                                                                                                                                                                                                                                                                                                      |
| `invalid_scope`               | La portée demandée n’est pas autorisée pour cette application ou ce type de connexion. Pour les [jetons d’une connexion de facturation](https://platform.claude.com/docs/fr/manage-claude/oauth-apps/oauth-reference#oauth-tokens-for-a-billing-connection), cela signifie également qu’une actualisation a envoyé un paramètre `scope`, qu’elle n’accepte pas, ou que `billing:attribution` n’est plus enregistrée pour votre application. Lors de l’échange du code, cette seconde cause consomme le code.                                                                                                                                                                                                |
| `invalid_grant`               | Le code a expiré, vous l’avez déjà utilisé, ou il ne correspond pas au `redirect_uri` ou au `code_verifier`. Pour une actualisation, le jeton d’actualisation a expiré ou n’est plus valide : suivez [Actualiser les jetons](https://platform.claude.com/docs/fr/manage-claude/oauth-apps/organization-billing-connections#refresh-the-connection).                                                                                                                                                                                                                                                                                                                                                         |
| `unauthorized_client`         | Votre application n’est pas configurée pour cette requête. Pour Linked billing, vérifiez d’abord le compte de service opérateur de l’application et son espace de travail : consultez [L’échange du code renvoie `unauthorized_client`](https://platform.claude.com/docs/fr/manage-claude/oauth-apps/organization-billing-connections#code-exchange-unauthorized-client). Pour les [jetons d’une connexion de facturation](https://platform.claude.com/docs/fr/manage-claude/oauth-apps/oauth-reference#oauth-tokens-for-a-billing-connection), `error_description` indique la cause, par exemple un espace de travail manquant. Ce refus ne consomme aucun code et ne révoque aucun jeton d’actualisation. |
| `user_profile_already_linked` | Linked billing uniquement, depuis le point de terminaison de jeton. Entre l’approbation et cette requête, le profil utilisateur a été lié à votre application via une autre organisation cliente, ou l’organisation du client a été liée via un autre profil utilisateur.                                                                                                                                                                                                                                                                                                                                                                                                                                   |

Si `auth.claude.com` applique une limite de débit à une requête, subit une panne, ou reçoit un `grant_type` inconnu ou un paramètre dépassant sa limite, il renvoie une erreur dans un format différent, qui peut ne pas être du JSON. Ne réessayez que sur les réponses HTTP 429 et 5xx, avec un délai d’attente progressif. Traitez tout autre statut comme une erreur dans la requête. Pour l’actualisation d’une connexion de facturation, suivez [Actualiser les jetons](https://platform.claude.com/docs/fr/manage-claude/oauth-apps/organization-billing-connections#refresh-the-connection) plutôt qu’un délai d’attente progressif général. Si la réponse comporte un en-tête `retry-after`, attendez au moins cette durée. Envoyez la requête suivante depuis votre propre code, et ne vous fiez pas aux nouvelles tentatives automatiques d’une bibliothèque cliente HTTP : elles peuvent ne pas s’exécuter pour une telle réponse. La section [Actualiser les jetons](https://platform.claude.com/docs/fr/manage-claude/oauth-apps/organization-billing-connections#refresh-the-connection) indique également quand une nouvelle tentative est sûre, car un jeton d’actualisation déjà utilisé peut mettre fin à la connexion lorsque vous l’envoyez de nouveau.

### Erreurs du point de terminaison de révocation

Pour la plupart des requêtes que `auth.claude.com` refuse, le point de terminaison de révocation renvoie HTTP 400 et un corps JSON avec `error` et `error_description`.

| Erreur                | Quand                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| --------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `invalid_request`     | Un paramètre obligatoire est manquant ou non valide, par exemple un `client_id` manquant. La requête n’envoie aucun des paramètres `token`, `connection_id` et `user_profile_id`, ou en envoie plus d’un. Un ID est mal formé, par exemple il a un préfixe incorrect. Un identifiant ou un `token` se trouve dans la chaîne de requête de l’URL. Le profil utilisateur a trop de connexions pour une seule requête : la requête a peut-être mis fin à certaines d’entre elles ; mettez donc fin aux autres avec `connection_id`. |
| `invalid_client`      | `auth.claude.com` n’a pas pu authentifier votre application. Pour savoir quoi vérifier, consultez `invalid_client` dans [Erreurs des points de terminaison PAR et de jeton](https://platform.claude.com/docs/fr/manage-claude/oauth-apps/oauth-reference#errors-from-the-par-and-token-endpoints).                                                                                                                                                                                                                               |
| `unauthorized_client` | Votre application n’est pas configurée pour cette requête. Contactez votre équipe de compte Anthropic.                                                                                                                                                                                                                                                                                                                                                                                                                           |

Les réponses du tableau suivant utilisent un format différent, qui peut ne pas être du JSON. Lorsque le corps est du JSON, `error` est un objet, et non une chaîne.

| Statut | Quand                                                                     | Ce qu’il faut faire                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| ------ | ------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| 400    | Un paramètre dépasse sa limite.                                           | Corrigez la requête. Ne réessayez pas.                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| 429    | Trop de requêtes ayant échoué proviennent de votre adresse IP.            | Réessayez avec un délai d’attente progressif.                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| 500    | `auth.claude.com` n’a pas réussi à traiter la requête.                    | Réessayez avec un délai d’attente progressif. Si le problème persiste, contactez votre équipe de compte Anthropic.                                                                                                                                                                                                                                                                                                                                                                      |
| 501    | Anthropic n’a pas activé ce point de terminaison pour votre organisation. | Ne réessayez pas. Contactez votre équipe de compte Anthropic.                                                                                                                                                                                                                                                                                                                                                                                                                           |
| 503    | La requête n’a pas abouti. Tout ce à quoi elle a mis fin reste terminé.   | Réessayez avec un délai d’attente progressif, avec les mêmes paramètres et une nouvelle assertion client. La nouvelle tentative termine le reste, et sa liste omet les connexions auxquelles la requête précédente a mis fin. Si vous avez envoyé `user_profile_id`, réessayez dans un délai d’un jour : passé ce délai, une nouvelle tentative peut renvoyer 200 avec une liste vide et ne rien terminer. Une nouvelle tentative avec chaque `connection_id` fonctionne à tout moment. |

### Erreurs de facturation

Celles-ci s’appliquent aux requêtes Claude API qui définissent `billing_policy.bill_to` sur `"user_profile"` ou qui s’authentifient avec [le jeton d’accès d’une connexion de facturation](https://platform.claude.com/docs/fr/manage-claude/oauth-apps/oauth-reference#oauth-tokens-for-a-billing-connection). La Claude API ne facture aucune des deux organisations pour une requête refusée. Aucune des réponses 402 et 403 ne peut faire l’objet d’une nouvelle tentative, à l’exception d’un refus `user_profile_not_billable` dans les 10 premières secondes suivant une nouvelle connexion.

| Statut | Type et code d’erreur                                      | Quand                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| ------ | ---------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| 400    | `invalid_request_error`                                    | La requête envoie `billing_policy` sans l’en-tête bêta `user-profiles-billing-2026-10-01`. Ou l’objet `billing_policy` comporte un champ manquant ou non valide. Avec le jeton d’accès d’une connexion de facturation, `bill_to` peut être omis. Ou la requête utilise l’exécution de code en dehors de la combinaison autorisée.                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| 400    | `invalid_request_error`, `user_profile_required`           | `bill_to` vaut `"user_profile"`, la requête n’inclut pas d’ID de profil utilisateur, et elle ne s’authentifie pas avec le jeton d’accès d’une connexion de facturation.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| 400    | `invalid_request_error`, sans code d’erreur                | La requête s’authentifie avec le jeton d’accès d’une connexion de facturation, et soit définit `bill_to` sur `"self"`, soit désigne un profil utilisateur autre que celui auquel le jeton est limité. Chacun de ces deux refus indique le problème dans `error.message`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| 401    | `authentication_error`                                     | La requête s’authentifie avec le jeton d’accès d’une connexion de facturation qui a expiré, qu’une actualisation a remplacé, ou dont la connexion a pris fin. Le message indique si le jeton a expiré ou a été révoqué. Renvoyez la requête avec le jeton d’accès actuel, ou liez de nouveau le client si la connexion a pris fin. Après la fin d’une connexion, chaque nouvelle requête effectuée avec son jeton d’accès peut recevoir cette erreur 401 ou une erreur 403 `user_profile_not_billable`, sans ordre fixe.                                                                                                                                                                                                                                                 |
| 402    | `billing_error`, `linked_organization_spend_limit_reached` | L’organisation cliente a atteint une limite de dépenses qu’elle a définie, pour votre application OAuth ou pour l’ensemble de l’organisation. La Claude API envoie le même code lorsque l’organisation ne dispose d’aucun crédit pouvant payer la requête. La réponse ne précise pas laquelle. Demandez au client de vérifier les deux limites et son solde de crédit. La section [Erreurs attendues](https://platform.claude.com/docs/fr/manage-claude/oauth-apps/organization-billing-connections#expected-errors) pour Linked billing indique où chacune est définie et ce qu’il faut modifier.                                                                                                                                                                       |
| 402    | `billing_error`, `linked_organization_billing_unavailable` | Anthropic ne peut pas actuellement facturer l’organisation cliente en raison d’un problème lié au propre compte Anthropic de cette organisation. Le même code met fin à une réponse que Claude a commencée lorsque le crédit de l’organisation s’épuise. Demandez au client de vérifier son statut de facturation auprès d’Anthropic.                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| 403    | `permission_error`, sans code d’erreur                     | Anthropic ne facture pas directement votre organisation ; il ne peut donc pas facturer des clients en votre nom.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| 403    | `permission_error`, `user_profile_not_billable`            | Le profil utilisateur n’a aucune connexion à une organisation cliente, un administrateur ou votre back-end a mis fin à la connexion, l’organisation cliente ne paie pas Anthropic directement pour son utilisation de l’API (les crédits prépayés et le paiement par facture comptent tous deux), ou la requête ne s’authentifie pas en tant que compte de service de votre application. La réponse ne précise pas laquelle de ces causes s’applique. Le jeton d’accès d’une connexion peut également la recevoir après la fin de la connexion. La section [Causes de `user_profile_not_billable`](https://platform.claude.com/docs/fr/manage-claude/oauth-apps/organization-billing-connections#user-profile-not-billable) indique ce qu’il faut vérifier pour chacune. |
| 503    | `overloaded_error`                                         | La Claude API ne peut temporairement pas confirmer si elle peut facturer le client. Réessayez la requête. Si la réponse inclut un en-tête `retry-after`, attendez cette durée avant de réessayer.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |

Sur `/v1/messages`, le code d’erreur se trouve dans `error.details.error_code`. Sur `/v1/chat/completions`, `error.type` vaut toujours `invalid_request_error`, `error.code` contient le type d’erreur Anthropic (par exemple `permission_error` ou `billing_error`), et la réponse ne contient pas de code d’erreur ; basez-vous donc sur le statut HTTP et sur `error.code`.

## Standards

| Standard                                                                              | Où il s’applique                                                                                                                                                                         |
| ------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [OAuth 2.0 (RFC 6749)](https://www.rfc-editor.org/rfc/rfc6749)                        | Flux de code d’autorisation, point de terminaison de jeton et réponses d’erreur                                                                                                          |
| [PKCE (RFC 7636)](https://www.rfc-editor.org/rfc/rfc7636)                             | Obligatoire avec `S256` sur chaque requête d’autorisation                                                                                                                                |
| [Requêtes d’autorisation poussées (RFC 9126)](https://www.rfc-editor.org/rfc/rfc9126) | Obligatoire pour Linked billing.                                                                                                                                                         |
| [Révocation de jeton (RFC 7009)](https://www.rfc-editor.org/rfc/rfc7009)              | Le point de terminaison de révocation, qui accepte également les ID de connexion et de profil utilisateur et renvoie les ID des connexions auxquelles il a mis fin                       |
| [Authentification client par JWT (RFC 7523)](https://www.rfc-editor.org/rfc/rfc7523)  | L’authentification client `private_key_jwt` aux points de terminaison PAR, de jeton et de révocation, et l’échange de jeton du compte de service pour les requêtes facturées à un client |

## Termes utilisés sur ces pages

Les définitions suivantes s’appliquent uniquement à Claude Platform OAuth.

| Terme                                | Signification                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| ------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Organisation Claude                  | Un compte d’organisation auprès d’Anthropic. Votre entreprise en possède un, tout comme chaque client qui relie son organisation pour la facturation.                                                                                                                                                                                                                                                                                                                                                         |
| Administrateur                       | Un membre d’une organisation Claude ayant le rôle Admin ou Facturation.                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| Application OAuth                    | L’enregistrement dans votre organisation Claude qui identifie votre produit auprès de `auth.claude.com`. Elle possède un ID client, un nom, un logo, une URL de page d’accueil, des URI de redirection et les types de connexion qu’elle prend en charge.                                                                                                                                                                                                                                                     |
| Type de connexion                    | Qui approuve une connexion : un administrateur au nom de toute une organisation (`organization_shared`, pour Linked billing).                                                                                                                                                                                                                                                                                                                                                                                 |
| Fournisseur d’identité               | Le service de votre propre infrastructure qui signe des JWT de courte durée pour votre back-end et publie ses clés publiques sous forme de JSON Web Key Set (JWKS), comme le service d’identité de charge de travail de votre fournisseur cloud ou votre propre émetteur conforme à OIDC. Sur ces pages, « votre fournisseur d’identité » désigne toujours ce service, et non Anthropic.                                                                                                                      |
| Assertion client                     | Un JWT de courte durée que votre fournisseur d’identité signe et que votre back-end envoie pour authentifier votre application OAuth. Il s’agit de la méthode d’authentification client `private_key_jwt` (RFC 7523).                                                                                                                                                                                                                                                                                         |
| Requête d’autorisation poussée (PAR) | Une requête dans laquelle votre back-end envoie les paramètres d’autorisation directement à `auth.claude.com` et reçoit un `request_uri` à utiliser dans la redirection du navigateur (RFC 9126).                                                                                                                                                                                                                                                                                                             |
| Workload Identity Federation         | La fonctionnalité de la Claude Console par laquelle votre organisation enregistre votre fournisseur d’identité, afin qu’Anthropic accepte les JWT signés avec les clés de votre JWKS.                                                                                                                                                                                                                                                                                                                         |
| Document de découverte               | Le document OIDC qui répertorie l’émetteur, les points de terminaison et les clés de signature d’Anthropic.                                                                                                                                                                                                                                                                                                                                                                                                   |
| Profil utilisateur                   | Un enregistrement que vous créez dans votre propre organisation Claude pour représenter l’un de vos clients. Une connexion de facturation relie un profil utilisateur à l’organisation Claude du client.                                                                                                                                                                                                                                                                                                      |
| Compte de service                    | Un compte non humain de votre organisation Claude. Pour Linked billing, votre application OAuth est liée à un compte de service, son compte de service opérateur, et votre back-end s’authentifie en tant que ce compte de service lorsqu’il envoie une requête facturée à un client.                                                                                                                                                                                                                         |
| Jetons OAuth de la connexion         | Le jeton d’accès que `auth.claude.com` renvoie pour une connexion de facturation, et le jeton d’actualisation qu’il renvoie lorsque le client a également approuvé `offline_access`. Le jeton d’accès s’authentifie en tant que compte de service opérateur et ne peut facturer que le profil utilisateur de cette connexion. Consultez [Jetons OAuth pour une connexion de facturation](https://platform.claude.com/docs/fr/manage-claude/oauth-apps/oauth-reference#oauth-tokens-for-a-billing-connection). |
