---
title: Gérer WIF avec l'Admin API
url: https://platform.claude.com/docs/fr/manage-claude/wif-admin-api
description: Créez et gérez par programmation les comptes de service, les émetteurs et les règles de Workload Identity Federation pour les workflows d'infrastructure as code et de CI.
---
L'Admin API vous permet de créer et de gérer par programmation les ressources de [Workload Identity Federation](https://platform.claude.com/docs/fr/manage-claude/workload-identity-federation) (fédération d'identité de charge de travail) : les « service accounts » (comptes de service), les « federation issuers » (émetteurs de fédération) et les « federation rules » (règles de fédération). Utilisez-la pour conserver votre configuration de fédération sous forme d'« infrastructure as code » (infrastructure en tant que code), la provisionner depuis la CI et la reproduire d'une organisation à l'autre au lieu de cliquer dans la Claude Console. Ces points de terminaison partagent le préfixe de chemin `/v1/organizations` avec le reste de l'[Admin API](https://platform.claude.com/docs/fr/manage-claude/admin-api).
## Prérequis
Chaque requête de cette page s'authentifie avec un « bearer token » (jeton porteur) OAuth qui porte le « scope » (portée) `org:admin`. Cette portée n'est accordée qu'aux membres de l'organisation ayant le rôle admin, owner ou primary owner, et elle donne accès à l'ensemble de l'organisation : toute liaison à un espace de travail est ignorée. Il existe deux façons d'obtenir un jeton, et elles confèrent des permissions différentes : un jeton issu de votre propre connexion agit en tant qu'utilisateur, tandis qu'un jeton fédéré agit en tant que compte de service et ne peut pas effectuer toutes les opérations de cette page.
### Interactif (votre terminal)
Connectez-vous avec la [CLI `ant`](https://platform.claude.com/docs/fr/cli-sdks-libraries/cli/quickstart) sous un profil dédié, en demandant la portée `org:admin` (voir [Accès administrateur](https://platform.claude.com/docs/fr/cli-sdks-libraries/cli/authentication#admin-access)), puis exportez le jeton porteur. La connexion avec `--profile admin` stocke l'identifiant `org:admin` sous son propre nom de profil et en fait également le profil actif de la CLI, et la variable exportée s'applique à chaque appel de SDK et de CLI dans ce shell ; utilisez donc un shell que vous réservez à l'administration, supprimez la variable lorsque vous avez terminé, et rebasculez la CLI avec `ant profile activate default` :
```bash CLI
ant auth login --profile admin --scope "org:admin"
export ANTHROPIC_AUTH_TOKEN=$(ant auth print-credentials --profile admin --access-token)
```
Les jetons interactifs ont une durée de vie courte ; si les requêtes commencent à renvoyer 401, réexécutez la commande d'export (elle actualise le jeton automatiquement).
Les SDK et la CLI `ant` lisent `ANTHROPIC_AUTH_TOKEN` automatiquement ; laissez `ANTHROPIC_API_KEY` non définie dans le même shell, car ces points de terminaison rejettent les clés API et certains clients préfèrent la clé lorsque les deux sont définies.
### Charge de travail (CI et automatisation)
Créez une règle de fédération avec `oauth_scope: org:admin` qui cible un compte de service dont l'`organization_role` est `admin`. La règle elle-même doit être créée dans la Claude Console : accorder à une « workload » (charge de travail) un accès administrateur d'organisation est une action humaine délibérée, et non quelque chose que l'automatisation peut amorcer pour elle-même. La section suivante décrit cette configuration à effectuer une fois par organisation.
## Amorcer une charge de travail pour gérer WIF
Une seule règle créée dans la Console suffit pour placer le reste de votre configuration de fédération sous infrastructure as code : accordez à une seule charge de travail de confiance la portée `org:admin`, et laissez cette charge de travail gérer les émetteurs de fédération et chaque règle de fédération à portée d'espace de travail via cette API.
Dans la Claude Console, accédez à la page [Workload identity](https://platform.claude.com/settings/workload-identity-federation) (`platform.claude.com/settings/workload-identity-federation`) et sélectionnez **Connect workload** pour créer une règle de fédération pour votre charge de travail d'automatisation, par exemple un workflow GitHub Actions dans votre dépôt d'infrastructure. Sous **Advanced rule options**, définissez la portée OAuth de la règle sur `org:admin` : l'assistant crée alors le nouveau compte de service avec le rôle d'organisation Admin (ou vous demande de choisir un compte de service administrateur existant comme cible).
Faites correspondre la règle à une seule identité de charge de travail exacte, et non à un motif large. `subject_prefix` est une correspondance exacte sauf s'il se termine par `*`. Pour GitHub Actions, épinglez le sujet à une branche protégée, telle que `repo:my-org/my-repo:ref:refs/heads/main`. Un caractère générique final tel que `repo:my-org/my-repo:*` correspond également aux exécutions `pull_request`, y compris celles déclenchées depuis des forks, de sorte que toute personne pouvant ouvrir une pull request sur le dépôt pourrait émettre un jeton `org:admin`. Voir [Restreindre les workflows autorisés à s'authentifier](https://platform.claude.com/docs/fr/manage-claude/wif-providers/github-actions#restrict-which-workflows-can-authenticate).
Une charge de travail qui utilise l'un des SDK ou la CLI `ant` n'effectue pas l'échange elle-même. Pointez le client vers la règle avec les variables d'environnement de fédération et construisez-le sans arguments, exactement comme pour l'inférence dans [Construire le client SDK](https://platform.claude.com/docs/fr/manage-claude/workload-identity-federation#construct-the-sdk-client) ; le client échange le jeton d'identité lors de la première requête et, avant l'expiration du jeton d'accès obtenu, relit le jeton d'identité et l'échange à nouveau :
```bash
export ANTHROPIC_FEDERATION_RULE_ID=fdrl_... # the org:admin rule from step 1
export ANTHROPIC_ORGANIZATION_ID=00000000-0000-0000-0000-000000000000
export ANTHROPIC_SERVICE_ACCOUNT_ID=svac_... # the rule's target service account
export ANTHROPIC_IDENTITY_TOKEN_FILE=/path/to/jwt # or ANTHROPIC_IDENTITY_TOKEN
# ANTHROPIC_WORKSPACE_ID n'est requis que si la règle est activée pour tous les
# espaces de travail ou plusieurs ; les points de terminaison org:admin ignorent la liaison.
unset ANTHROPIC_API_KEY ANTHROPIC_AUTH_TOKEN # both take precedence over federation
```
La CLI `ant` lit les mêmes variables, ou accepte les options `--federation-rule`, `--organization-id`, `--service-account-id` et `--identity-token-file`. Pour une charge de travail qui exécute plus d'une commande `ant`, utilisez un [profil de fédération](https://platform.claude.com/docs/fr/manage-claude/wif-reference#profile-configuration-file) plutôt que des options ou des variables d'environnement : avec des options ou des variables, la CLI échange à nouveau le jeton d'identité dans chaque processus, et les jetons d'identité qui portent une revendication `jti` (c'est le cas des jetons GitHub Actions) ne sont acceptés qu'une seule fois, de sorte qu'une deuxième commande serait rejetée ; un profil est également le seul moyen de fournir à la CLI un `workspace_id` pour l'échange lorsque la règle est activée pour tous les espaces de travail ou pour plusieurs, car contrairement aux SDK, la CLI ne transmet pas `ANTHROPIC_WORKSPACE_ID` ni `--workspace-id` dans l'échange. Chaque SDK accepte également les mêmes paramètres sous forme d'arguments explicites du constructeur, présentés par langage dans [Construire le client SDK](https://platform.claude.com/docs/fr/manage-claude/workload-identity-federation#construct-the-sdk-client). Voir [Variables d'environnement](https://platform.claude.com/docs/fr/manage-claude/wif-reference#environment-variables) et [Priorité des identifiants](https://platform.claude.com/docs/fr/manage-claude/wif-reference#credential-precedence) pour la liste complète et l'ordre de priorité.
Une charge de travail qui appelle l'API avec curl échange elle-même le JWT contre un jeton porteur `org:admin` de courte durée, en utilisant le même [échange de jeton](https://platform.claude.com/docs/fr/manage-claude/workload-identity-federation#authenticate-from-your-workload) que toute autre charge de travail fédérée, et l'envoie dans l'en-tête `authorization: Bearer`.
Une fois le client configuré (ou, pour curl, le jeton émis placé dans `ANTHROPIC_AUTH_TOKEN`), la charge de travail crée et gère votre configuration de fédération à l'aide des points de terminaison de cette page.
Pour connaître les opérations qu'un jeton émis par une charge de travail peut et ne peut pas effectuer, voir [Permissions et contraintes](https://platform.claude.com/docs/fr/manage-claude/wif-admin-api#permissions-and-constraints). Si vous avez déjà créé des émetteurs, des comptes de service ou des règles avec l'assistant **Connect workload**, listez-les avec les points de terminaison suivants et importez-les dans l'état de votre infrastructure as code au lieu de les recréer.
## Authentification
Tous les points de terminaison se trouvent sous `https://api.anthropic.com/v1/organizations/`. Chaque requête vers les points de terminaison de fédération et de comptes de service nécessite l'en-tête de version de l'API et le jeton porteur :
Dans les SDK, ces points de terminaison sont `client.organization.service_accounts` (typescript: `client.organization.serviceAccounts`; csharp, go: `client.Organization.ServiceAccounts`; java: `client.organization().serviceAccounts()`; php: `$client->organization->serviceAccounts`), `client.organization.federation.issuers` (csharp, go: `client.Organization.Federation.Issuers`; java: `client.organization().federation().issuers()`; php: `$client->organization->federation->issuers`) et `client.organization.federation.rules` (csharp, go: `client.Organization.Federation.Rules`; java: `client.organization().federation().rules()`; php: `$client->organization->federation->rules`) (`ant organization:service-accounts`, `federation:issuers` et `federation:rules` dans la CLI). Les exemples SDK et CLI construisent le client par défaut, qui envoie le jeton porteur depuis `ANTHROPIC_AUTH_TOKEN` ou, dans une charge de travail automatisée, effectue lui-même l'échange de fédération comme décrit dans [Amorcer une charge de travail pour gérer WIF](https://platform.claude.com/docs/fr/manage-claude/wif-admin-api#bootstrap-a-workload-to-manage-wif). Les méthodes de liste des SDK récupèrent les pages suivantes à la demande, donc `limit` définit la taille de page ; les exemples PHP et Ruby lisent une seule page.
```bash cURL
curl --fail-with-body -sS "https://api.anthropic.com/v1/organizations/service_accounts" \
-H "authorization: Bearer $ANTHROPIC_AUTH_TOKEN" \
-H "anthropic-version: 2023-06-01"
```
```bash CLI
ant organization:service-accounts list
```
```python Python
client = anthropic.Anthropic()
service_accounts = client.organization.service_accounts.list()
for service_account in service_accounts:
print(f"{service_account.id}: {service_account.name}")
```
```typescript TypeScript
const client = new Anthropic();
for await (const serviceAccount of client.organization.serviceAccounts.list()) {
console.log(`${serviceAccount.id}: ${serviceAccount.name}`);
}
```
```csharp C#
AnthropicClient client = new();
var page = await client.Organization.ServiceAccounts.List();
await foreach (var serviceAccount in page.Paginate())
{
Console.WriteLine($"{serviceAccount.ID}: {serviceAccount.Name}");
}
```
```go Go
client := anthropic.NewClient()
serviceAccounts := client.Organization.ServiceAccounts.ListAutoPaging(context.Background(), anthropic.OrganizationServiceAccountListParams{})
for serviceAccounts.Next() {
serviceAccount := serviceAccounts.Current()
fmt.Printf("%s: %s\n", serviceAccount.ID, serviceAccount.Name)
}
if err := serviceAccounts.Err(); err != nil {
log.Fatal(err)
}
```
```java Java
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
var serviceAccounts = client.organization().serviceAccounts().list();
for (var serviceAccount : serviceAccounts.autoPager()) {
IO.println(serviceAccount.id() + ": " + serviceAccount.name());
}
```
```php PHP
$client = new Client();
$serviceAccounts = $client->organization->serviceAccounts->list();
foreach ($serviceAccounts->getItems() as $serviceAccount) {
echo "{$serviceAccount->id}: {$serviceAccount->name}\n";
}
```
```ruby Ruby
client = Anthropic::Client.new
service_accounts = client.organization.service_accounts.list
service_accounts.data.each do |service_account|
puts "#{service_account.id}: #{service_account.name}"
end
```
Les clés Admin API ne sont pas acceptées sur ces points de terminaison ; les exemples `x-api-key` de la page Admin API ne s'appliquent pas ici.
## Comptes de service
Un [compte de service](https://platform.claude.com/docs/fr/manage-claude/workload-identity-federation#service-accounts) (`svac_...`) est l'identité non humaine en tant que laquelle agit un jeton fédéré. Définissez `organization_role` sur `developer`.
Créer un compte de service :
```bash cURL
curl --fail-with-body -sS "https://api.anthropic.com/v1/organizations/service_accounts" \
-H "authorization: Bearer $ANTHROPIC_AUTH_TOKEN" \
-H "anthropic-version: 2023-06-01" \
-H "content-type: application/json" \
-d '{
"name": "inference-worker",
"organization_role": "developer"
}'
```
```bash CLI
ant organization:service-accounts create \
--name inference-worker \
--organization-role developer
```
```python Python
client = anthropic.Anthropic()
service_account = client.organization.service_accounts.create(
name="inference-worker", organization_role="developer"
)
print(f"id: {service_account.id}")
print(f"name: {service_account.name}")
```
```typescript TypeScript
const client = new Anthropic();
const serviceAccount = await client.organization.serviceAccounts.create({
name: "inference-worker",
organization_role: "developer"
});
console.log(`id: ${serviceAccount.id}`);
console.log(`name: ${serviceAccount.name}`);
```
```csharp C#
using Anthropic.Models.Organization.ServiceAccounts;
AnthropicClient client = new();
var serviceAccount = await client.Organization.ServiceAccounts.Create(new()
{
Name = "inference-worker",
OrganizationRole = OrganizationRole.Developer
});
Console.WriteLine($"id: {serviceAccount.ID}");
Console.WriteLine($"name: {serviceAccount.Name}");
```
```go Go
client := anthropic.NewClient()
serviceAccount, err := client.Organization.ServiceAccounts.New(context.Background(), anthropic.OrganizationServiceAccountNewParams{
Name: "inference-worker",
OrganizationRole: anthropic.OrganizationServiceAccountNewParamsOrganizationRoleDeveloper,
})
if err != nil {
log.Fatal(err)
}
fmt.Printf("id: %s\n", serviceAccount.ID)
fmt.Printf("name: %s\n", serviceAccount.Name)
```
```java Java
import com.anthropic.models.organization.serviceaccounts.ServiceAccountCreateParams;
void main() {
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
var params = ServiceAccountCreateParams.builder()
.name("inference-worker")
.organizationRole(ServiceAccountCreateParams.OrganizationRole.DEVELOPER)
.build();
var serviceAccount = client.organization().serviceAccounts().create(params);
IO.println("id: " + serviceAccount.id());
IO.println("name: " + serviceAccount.name());
}
```
```php PHP
use Anthropic\Organization\ServiceAccounts\ServiceAccountCreateParams\OrganizationRole;
// ...
$client = new Client();
$serviceAccount = $client->organization->serviceAccounts->create(
name: 'inference-worker',
organizationRole: OrganizationRole::DEVELOPER,
);
echo "id: {$serviceAccount->id}\n";
echo "name: {$serviceAccount->name}\n";
```
```ruby Ruby
client = Anthropic::Client.new
service_account = client.organization.service_accounts.create(
name: "inference-worker",
organization_role: :developer
)
puts "id: #{service_account.id}"
puts "name: #{service_account.name}"
```
Lister les comptes de service :
```bash cURL
curl --fail-with-body -sS "https://api.anthropic.com/v1/organizations/service_accounts?limit=20" \
-H "authorization: Bearer $ANTHROPIC_AUTH_TOKEN" \
-H "anthropic-version: 2023-06-01"
```
```bash CLI
ant organization:service-accounts list --limit 20
```
```python Python
client = anthropic.Anthropic()
service_accounts = client.organization.service_accounts.list(limit=20)
for service_account in service_accounts:
print(f"{service_account.id}: {service_account.name}")
```
```typescript TypeScript
const client = new Anthropic();
for await (const serviceAccount of client.organization.serviceAccounts.list({
limit: 20
})) {
console.log(`${serviceAccount.id}: ${serviceAccount.name}`);
}
```
```csharp C#
AnthropicClient client = new();
var page = await client.Organization.ServiceAccounts.List(new() { Limit = 20 });
await foreach (var serviceAccount in page.Paginate())
{
Console.WriteLine($"{serviceAccount.ID}: {serviceAccount.Name}");
}
```
```go Go
client := anthropic.NewClient()
serviceAccounts := client.Organization.ServiceAccounts.ListAutoPaging(context.Background(), anthropic.OrganizationServiceAccountListParams{
Limit: anthropic.Int(20),
})
for serviceAccounts.Next() {
serviceAccount := serviceAccounts.Current()
fmt.Printf("%s: %s\n", serviceAccount.ID, serviceAccount.Name)
}
if err := serviceAccounts.Err(); err != nil {
log.Fatal(err)
}
```
```java Java
import com.anthropic.models.organization.serviceaccounts.ServiceAccountListParams;
void main() {
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
var params = ServiceAccountListParams.builder()
.limit(20)
.build();
var serviceAccounts = client.organization().serviceAccounts().list(params);
for (var serviceAccount : serviceAccounts.autoPager()) {
IO.println(serviceAccount.id() + ": " + serviceAccount.name());
}
}
```
```php PHP
$client = new Client();
$serviceAccounts = $client->organization->serviceAccounts->list(limit: 20);
foreach ($serviceAccounts->getItems() as $serviceAccount) {
echo "{$serviceAccount->id}: {$serviceAccount->name}\n";
}
```
```ruby Ruby
client = Anthropic::Client.new
service_accounts = client.organization.service_accounts.list(limit: 20)
service_accounts.data.each do |service_account|
puts "#{service_account.id}: #{service_account.name}"
end
```
Archiver un compte de service :
```bash cURL
curl --fail-with-body -sS -X POST "https://api.anthropic.com/v1/organizations/service_accounts/svac_01ABCDEFabcdef0123456789XY/archive" \
-H "authorization: Bearer $ANTHROPIC_AUTH_TOKEN" \
-H "anthropic-version: 2023-06-01"
```
```bash CLI
ant organization:service-accounts archive svac_01ABCDEFabcdef0123456789XY
```
```python Python
client = anthropic.Anthropic()
service_account = client.organization.service_accounts.archive(
"svac_01ABCDEFabcdef0123456789XY"
)
print(f"id: {service_account.id}")
print(f"archived_at: {service_account.archived_at}")
```
```typescript TypeScript
const client = new Anthropic();
const serviceAccount = await client.organization.serviceAccounts.archive(
"svac_01ABCDEFabcdef0123456789XY"
);
console.log(`id: ${serviceAccount.id}`);
console.log(`archived_at: ${serviceAccount.archived_at}`);
```
```csharp C#
AnthropicClient client = new();
var serviceAccount = await client.Organization.ServiceAccounts.Archive(
"svac_01ABCDEFabcdef0123456789XY"
);
Console.WriteLine($"id: {serviceAccount.ID}");
Console.WriteLine($"archived_at: {serviceAccount.ArchivedAt:O}");
```
```go Go
client := anthropic.NewClient()
serviceAccount, err := client.Organization.ServiceAccounts.Archive(
context.Background(),
"svac_01ABCDEFabcdef0123456789XY",
)
if err != nil {
log.Fatal(err)
}
fmt.Printf("id: %s\n", serviceAccount.ID)
fmt.Printf("archived_at: %s\n", serviceAccount.ArchivedAt)
```
```java Java
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
var serviceAccount = client.organization().serviceAccounts()
.archive("svac_01ABCDEFabcdef0123456789XY");
IO.println("id: " + serviceAccount.id());
IO.println("archived_at: " + serviceAccount.archivedAt().orElseThrow());
```
```php PHP
$client = new Client();
$serviceAccount = $client->organization->serviceAccounts->archive(
serviceAccountID: 'svac_01ABCDEFabcdef0123456789XY',
);
echo "id: {$serviceAccount->id}\n";
echo "archived_at: {$serviceAccount->archivedAt?->format(DATE_ATOM)}\n";
```
```ruby Ruby
client = Anthropic::Client.new
service_account_id = "svac_01ABCDEFabcdef0123456789XY"
service_account = client.organization.service_accounts.archive(service_account_id)
puts "id: #{service_account.id}"
puts "archived_at: #{service_account.archived_at}"
```
Le point de terminaison de création renvoie le nouveau compte de service :
```json
{
"id": "svac_...",
"name": "inference-worker",
"organization_role": "developer",
"created_at": "...",
"type": "service_account",
"...": "..."
}
```
Pour lire ou mettre à jour un compte de service individuel, utilisez `GET` et `POST` sur `/v1/organizations/service_accounts/{service_account_id}`. Un compte de service doit être membre d'un espace de travail avant que des jetons fédérés puissent y agir. Chaque compte de service dispose d'une appartenance implicite à l'espace de travail par défaut de votre organisation ; ajoutez des appartenances explicites pour d'autres espaces de travail avec `GET`, `POST` et `DELETE` sur `/v1/organizations/service_accounts/{service_account_id}/workspaces`, où `DELETE` cible `.../workspaces/{workspace_id}`.
Pour le détail complet des paramètres et les schémas de réponse, consultez la [référence API des comptes de service](https://platform.claude.com/docs/fr/api/organization/service_accounts).
## Émetteurs de fédération
Un [émetteur de fédération](https://platform.claude.com/docs/fr/manage-claude/workload-identity-federation#federation-issuers) (`fdis_...`) enregistre un fournisseur d'identité OIDC auprès de votre organisation. Le champ `jwks` est une union discriminée qui contrôle la manière dont Anthropic récupère les clés de signature du fournisseur :
| Valeur de `jwks` | Quand l'utiliser |
| ---------------------------------------- | ----------------------------------------------------------------------------------------------------- |
| `{"type": "discovery"}` | Le fournisseur sert `/.well-known/openid-configuration` à l'URL de l'émetteur. |
| `{"type": "explicit_url", "url": "..."}` | Pointer directement vers un point de terminaison JWKS. |
| `{"type": "inline", "keys": [...]}` | Téléverser le jeu de clés pour les fournisseurs qui ne sont pas accessibles depuis l'internet public. |
Enregistrer un émetteur. Cet exemple enregistre GitHub Actions avec la découverte JWKS :
```bash cURL
curl --fail-with-body -sS "https://api.anthropic.com/v1/organizations/federation_issuers" \
-H "authorization: Bearer $ANTHROPIC_AUTH_TOKEN" \
-H "anthropic-version: 2023-06-01" \
-H "content-type: application/json" \
-d '{
"name": "github-actions",
"issuer_url": "https://token.actions.githubusercontent.com",
"jwks": {"type": "discovery"}
}'
```
```bash CLI
ant organization:federation:issuers create \
--name github-actions \
--issuer-url https://token.actions.githubusercontent.com \
--jwks '{type: discovery}'
```
```python Python
client = anthropic.Anthropic()
issuer = client.organization.federation.issuers.create(
name="github-actions",
issuer_url="https://token.actions.githubusercontent.com",
jwks={"type": "discovery"},
)
print(f"id: {issuer.id}")
print(f"name: {issuer.name}")
print(f"issuer_url: {issuer.issuer_url}")
```
```typescript TypeScript
const client = new Anthropic();
const issuer = await client.organization.federation.issuers.create({
name: "github-actions",
issuer_url: "https://token.actions.githubusercontent.com",
jwks: { type: "discovery" }
});
console.log(`id: ${issuer.id}`);
console.log(`name: ${issuer.name}`);
console.log(`issuer_url: ${issuer.issuer_url}`);
```
```csharp C#
using Anthropic.Models.Organization.Federation.Issuers;
AnthropicClient client = new();
var issuer = await client.Organization.Federation.Issuers.Create(new()
{
Name = "github-actions",
IssuerUrl = "https://token.actions.githubusercontent.com",
Jwks = new JwksDiscovery()
});
Console.WriteLine($"id: {issuer.ID}");
Console.WriteLine($"name: {issuer.Name}");
Console.WriteLine($"issuer_url: {issuer.IssuerUrl}");
```
```go Go
client := anthropic.NewClient()
issuer, err := client.Organization.Federation.Issuers.New(context.Background(), anthropic.OrganizationFederationIssuerNewParams{
Name: "github-actions",
IssuerURL: "https://token.actions.githubusercontent.com",
JWKS: anthropic.OrganizationFederationIssuerNewParamsJWKSUnion{
OfDiscovery: &anthropic.JWKSDiscoveryParam{},
},
})
if err != nil {
log.Fatal(err)
}
fmt.Printf("id: %s\n", issuer.ID)
fmt.Printf("name: %s\n", issuer.Name)
fmt.Printf("issuer_url: %s\n", issuer.IssuerURL)
```
```java Java
import com.anthropic.models.organization.federation.issuers.JwksDiscovery;
import com.anthropic.models.organization.federation.issuers.IssuerCreateParams;
void main() {
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
var params = IssuerCreateParams.builder()
.name("github-actions")
.issuerUrl("https://token.actions.githubusercontent.com")
.jwks(JwksDiscovery.builder().build())
.build();
var issuer = client.organization().federation().issuers().create(params);
IO.println("id: " + issuer.id());
IO.println("name: " + issuer.name());
IO.println("issuer_url: " + issuer.issuerUrl());
}
```
```php PHP
$client = new Client();
$issuer = $client->organization->federation->issuers->create(
name: 'github-actions',
issuerURL: 'https://token.actions.githubusercontent.com',
jwks: ['type' => 'discovery'],
);
echo "id: {$issuer->id}\n";
echo "name: {$issuer->name}\n";
echo "issuer_url: {$issuer->issuerURL}\n";
```
```ruby Ruby
client = Anthropic::Client.new
issuer = client.organization.federation.issuers.create(
name: "github-actions",
issuer_url: "https://token.actions.githubusercontent.com",
jwks: {type: :discovery}
)
puts "id: #{issuer.id}"
puts "name: #{issuer.name}"
puts "issuer_url: #{issuer.issuer_url}"
```
Lister les émetteurs :
```bash cURL
curl --fail-with-body -sS "https://api.anthropic.com/v1/organizations/federation_issuers?limit=20" \
-H "authorization: Bearer $ANTHROPIC_AUTH_TOKEN" \
-H "anthropic-version: 2023-06-01"
```
```bash CLI
ant organization:federation:issuers list --limit 20
```
```python Python
client = anthropic.Anthropic()
issuers = client.organization.federation.issuers.list(limit=20)
for issuer in issuers:
print(f"{issuer.id}: {issuer.name}")
```
```typescript TypeScript
const client = new Anthropic();
for await (const issuer of client.organization.federation.issuers.list({ limit: 20 })) {
console.log(`${issuer.id}: ${issuer.name}`);
}
```
```csharp C#
AnthropicClient client = new();
var page = await client.Organization.Federation.Issuers.List(new() { Limit = 20 });
await foreach (var issuer in page.Paginate())
{
Console.WriteLine($"{issuer.ID}: {issuer.Name}");
}
```
```go Go
client := anthropic.NewClient()
issuers := client.Organization.Federation.Issuers.ListAutoPaging(context.Background(), anthropic.OrganizationFederationIssuerListParams{
Limit: anthropic.Int(20),
})
for issuers.Next() {
issuer := issuers.Current()
fmt.Printf("%s: %s\n", issuer.ID, issuer.Name)
}
if err := issuers.Err(); err != nil {
log.Fatal(err)
}
```
```java Java
import com.anthropic.models.organization.federation.issuers.IssuerListParams;
void main() {
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
var params = IssuerListParams.builder()
.limit(20)
.build();
var issuers = client.organization().federation().issuers().list(params);
for (var issuer : issuers.autoPager()) {
IO.println(issuer.id() + ": " + issuer.name());
}
}
```
```php PHP
$client = new Client();
$issuers = $client->organization->federation->issuers->list(limit: 20);
foreach ($issuers->getItems() as $issuer) {
echo "{$issuer->id}: {$issuer->name}\n";
}
```
```ruby Ruby
client = Anthropic::Client.new
issuers = client.organization.federation.issuers.list(limit: 20)
issuers.data.each do |issuer|
puts "#{issuer.id}: #{issuer.name}"
end
```
Archiver un émetteur :
```bash cURL
curl --fail-with-body -sS -X POST "https://api.anthropic.com/v1/organizations/federation_issuers/fdis_01ABCDEFabcdef0123456789XY/archive" \
-H "authorization: Bearer $ANTHROPIC_AUTH_TOKEN" \
-H "anthropic-version: 2023-06-01"
```
```bash CLI
ant organization:federation:issuers archive \
--federation-issuer-id fdis_01ABCDEFabcdef0123456789XY
```
```python Python
client = anthropic.Anthropic()
issuer = client.organization.federation.issuers.archive(
"fdis_01ABCDEFabcdef0123456789XY"
)
print(f"id: {issuer.id}")
print(f"archived_at: {issuer.archived_at}")
```
```typescript TypeScript
const client = new Anthropic();
const issuer = await client.organization.federation.issuers.archive(
"fdis_01ABCDEFabcdef0123456789XY"
);
console.log(`id: ${issuer.id}`);
console.log(`archived_at: ${issuer.archived_at}`);
```
```csharp C#
AnthropicClient client = new();
var issuer = await client.Organization.Federation.Issuers.Archive(
"fdis_01ABCDEFabcdef0123456789XY"
);
Console.WriteLine($"id: {issuer.ID}");
Console.WriteLine($"archived_at: {issuer.ArchivedAt:O}");
```
```go Go
client := anthropic.NewClient()
issuer, err := client.Organization.Federation.Issuers.Archive(
context.Background(),
"fdis_01ABCDEFabcdef0123456789XY",
)
if err != nil {
log.Fatal(err)
}
fmt.Printf("id: %s\n", issuer.ID)
fmt.Printf("archived_at: %s\n", issuer.ArchivedAt)
```
```java Java
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
var issuer = client.organization().federation().issuers()
.archive("fdis_01ABCDEFabcdef0123456789XY");
IO.println("id: " + issuer.id());
IO.println("archived_at: " + issuer.archivedAt().orElseThrow());
```
```php PHP
$client = new Client();
$issuer = $client->organization->federation->issuers->archive(
federationIssuerID: 'fdis_01ABCDEFabcdef0123456789XY',
);
echo "id: {$issuer->id}\n";
echo "archived_at: {$issuer->archivedAt?->format(DATE_ATOM)}\n";
```
```ruby Ruby
client = Anthropic::Client.new
issuer_id = "fdis_01ABCDEFabcdef0123456789XY"
issuer = client.organization.federation.issuers.archive(issuer_id)
puts "id: #{issuer.id}"
puts "archived_at: #{issuer.archived_at}"
```
Pour lire ou mettre à jour un émetteur individuel, utilisez `GET` et `POST` sur `/v1/organizations/federation_issuers/{issuer_id}`. Un appelant OAuth ne peut pas mettre à jour un émetteur qui sous-tend une règle dont l'`oauth_scope` est autre que `workspace:developer` ou `workspace:inference` ; voir [Permissions et contraintes](https://platform.claude.com/docs/fr/manage-claude/wif-admin-api#permissions-and-constraints).
Pour le détail complet des paramètres et les schémas de réponse, consultez la [référence API des émetteurs de fédération](https://platform.claude.com/docs/fr/api/organization/federation/issuers).
## Règles de fédération
Une [règle de fédération](https://platform.claude.com/docs/fr/manage-claude/workload-identity-federation#federation-rules) (`fdrl_...`) lie un émetteur à un compte de service : les JWT de l'émetteur qui satisfont les conditions de correspondance de la règle peuvent émettre des jetons qui agissent en tant que cible de la règle. Le `workspace_id` dans la requête de création active la règle dans cet espace de travail dès la création ; ajoutez d'autres espaces de travail ultérieurement via la sous-ressource `/federation_rules/{rule_id}/workspaces`. Soit `workspace_id`, soit `applies_to_all_workspaces: true` est requis à la création.
Créer une règle. Cet exemple permet aux déploiements GitHub Actions depuis la branche main d'agir en tant que compte de service :
```bash cURL
curl --fail-with-body -sS "https://api.anthropic.com/v1/organizations/federation_rules" \
-H "authorization: Bearer $ANTHROPIC_AUTH_TOKEN" \
-H "anthropic-version: 2023-06-01" \
-H "content-type: application/json" \
-d '{
"name": "gha-deploy",
"issuer_id": "fdis_01ABCDEFabcdef0123456789XY",
"match": {
"subject_prefix": "repo:my-org/my-repo:ref:refs/heads/main",
"claims": {"repository_owner": "my-org"}
},
"target": {
"type": "service_account",
"service_account_id": "svac_01ABCDEFabcdef0123456789XY"
},
"workspace_id": "wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ",
"oauth_scope": "workspace:developer",
"token_lifetime_seconds": 600
}'
```
```bash CLI
ant organization:federation:rules create <<'YAML'
name: gha-deploy
issuer_id: fdis_01ABCDEFabcdef0123456789XY
match:
subject_prefix: "repo:my-org/my-repo:ref:refs/heads/main"
claims:
repository_owner: my-org
target:
type: service_account
service_account_id: svac_01ABCDEFabcdef0123456789XY
workspace_id: wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ
oauth_scope: "workspace:developer"
token_lifetime_seconds: 600
YAML
```
```python Python
client = anthropic.Anthropic()
rule = client.organization.federation.rules.create(
name="gha-deploy",
issuer_id="fdis_01ABCDEFabcdef0123456789XY",
match={
"subject_prefix": "repo:my-org/my-repo:ref:refs/heads/main",
"claims": {"repository_owner": "my-org"},
},
target={
"type": "service_account",
"service_account_id": "svac_01ABCDEFabcdef0123456789XY",
},
workspace_id="wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ",
oauth_scope="workspace:developer",
token_lifetime_seconds=600,
)
print(f"id: {rule.id}")
print(f"name: {rule.name}")
```
```typescript TypeScript
const client = new Anthropic();
const rule = await client.organization.federation.rules.create({
name: "gha-deploy",
issuer_id: "fdis_01ABCDEFabcdef0123456789XY",
match: {
subject_prefix: "repo:my-org/my-repo:ref:refs/heads/main",
claims: { repository_owner: "my-org" }
},
target: {
type: "service_account",
service_account_id: "svac_01ABCDEFabcdef0123456789XY"
},
workspace_id: "wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ",
oauth_scope: "workspace:developer",
token_lifetime_seconds: 600
});
console.log(`id: ${rule.id}`);
console.log(`name: ${rule.name}`);
```
```csharp C#
AnthropicClient client = new();
var rule = await client.Organization.Federation.Rules.Create(new()
{
Name = "gha-deploy",
IssuerID = "fdis_01ABCDEFabcdef0123456789XY",
Match = new()
{
SubjectPrefix = "repo:my-org/my-repo:ref:refs/heads/main",
Claims = new Dictionary { ["repository_owner"] = "my-org" }
},
Target = new() { ServiceAccountID = "svac_01ABCDEFabcdef0123456789XY" },
WorkspaceID = "wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ",
OAuthScope = "workspace:developer",
TokenLifetimeSeconds = 600
});
Console.WriteLine($"id: {rule.ID}");
Console.WriteLine($"name: {rule.Name}");
```
```go Go
client := anthropic.NewClient()
rule, err := client.Organization.Federation.Rules.New(context.Background(), anthropic.OrganizationFederationRuleNewParams{
Name: "gha-deploy",
IssuerID: "fdis_01ABCDEFabcdef0123456789XY",
Match: anthropic.FederationRuleMatchParam{
SubjectPrefix: anthropic.String("repo:my-org/my-repo:ref:refs/heads/main"),
Claims: map[string]string{"repository_owner": "my-org"},
},
Target: anthropic.ServiceAccountTargetParam{
ServiceAccountID: "svac_01ABCDEFabcdef0123456789XY",
},
WorkspaceID: anthropic.String("wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ"),
OAuthScope: "workspace:developer",
TokenLifetimeSeconds: anthropic.Int(600),
})
if err != nil {
log.Fatal(err)
}
fmt.Printf("id: %s\n", rule.ID)
fmt.Printf("name: %s\n", rule.Name)
```
```java Java
import com.anthropic.core.JsonValue;
import com.anthropic.models.organization.federation.rules.FederationRuleMatch;
import com.anthropic.models.organization.federation.rules.ServiceAccountTarget;
import com.anthropic.models.organization.federation.rules.RuleCreateParams;
void main() {
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
var match = FederationRuleMatch.builder()
.subjectPrefix("repo:my-org/my-repo:ref:refs/heads/main")
.claims(FederationRuleMatch.Claims.builder()
.putAdditionalProperty("repository_owner", JsonValue.from("my-org"))
.build())
.build();
var params = RuleCreateParams.builder()
.name("gha-deploy")
.issuerId("fdis_01ABCDEFabcdef0123456789XY")
.match(match)
.target(ServiceAccountTarget.of("svac_01ABCDEFabcdef0123456789XY"))
.workspaceId("wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ")
.oauthScope("workspace:developer")
.tokenLifetimeSeconds(600)
.build();
var rule = client.organization().federation().rules().create(params);
IO.println("id: " + rule.id());
IO.println("name: " + rule.name());
}
```
```php PHP
$client = new Client();
$rule = $client->organization->federation->rules->create(
name: 'gha-deploy',
issuerID: 'fdis_01ABCDEFabcdef0123456789XY',
match: [
'subjectPrefix' => 'repo:my-org/my-repo:ref:refs/heads/main',
'claims' => ['repository_owner' => 'my-org'],
],
target: [
'type' => 'service_account',
'serviceAccountID' => 'svac_01ABCDEFabcdef0123456789XY',
],
workspaceID: 'wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ',
oauthScope: 'workspace:developer',
tokenLifetimeSeconds: 600,
);
echo "id: {$rule->id}\n";
echo "name: {$rule->name}\n";
```
```ruby Ruby
client = Anthropic::Client.new
rule = client.organization.federation.rules.create(
name: "gha-deploy",
issuer_id: "fdis_01ABCDEFabcdef0123456789XY",
match: {
subject_prefix: "repo:my-org/my-repo:ref:refs/heads/main",
claims: {repository_owner: "my-org"}
},
target: {
type: :service_account,
service_account_id: "svac_01ABCDEFabcdef0123456789XY"
},
workspace_id: "wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ",
oauth_scope: "workspace:developer",
token_lifetime_seconds: 600
)
puts "id: #{rule.id}"
puts "name: #{rule.name}"
```
Lister les règles, éventuellement filtrées par émetteur :
```bash cURL
curl --fail-with-body -sS "https://api.anthropic.com/v1/organizations/federation_rules?issuer_id=fdis_01ABCDEFabcdef0123456789XY" \
-H "authorization: Bearer $ANTHROPIC_AUTH_TOKEN" \
-H "anthropic-version: 2023-06-01"
```
```bash CLI
ant organization:federation:rules list \
--issuer-id fdis_01ABCDEFabcdef0123456789XY
```
```python Python
client = anthropic.Anthropic()
rules = client.organization.federation.rules.list(
issuer_id="fdis_01ABCDEFabcdef0123456789XY"
)
for rule in rules:
print(f"{rule.id}: {rule.name}")
```
```typescript TypeScript
const client = new Anthropic();
for await (const rule of client.organization.federation.rules.list({
issuer_id: "fdis_01ABCDEFabcdef0123456789XY"
})) {
console.log(`${rule.id}: ${rule.name}`);
}
```
```csharp C#
AnthropicClient client = new();
var page = await client.Organization.Federation.Rules.List(new()
{
IssuerID = "fdis_01ABCDEFabcdef0123456789XY"
});
await foreach (var rule in page.Paginate())
{
Console.WriteLine($"{rule.ID}: {rule.Name}");
}
```
```go Go
client := anthropic.NewClient()
rules := client.Organization.Federation.Rules.ListAutoPaging(context.Background(), anthropic.OrganizationFederationRuleListParams{
IssuerID: anthropic.String("fdis_01ABCDEFabcdef0123456789XY"),
})
for rules.Next() {
rule := rules.Current()
fmt.Printf("%s: %s\n", rule.ID, rule.Name)
}
if err := rules.Err(); err != nil {
log.Fatal(err)
}
```
```java Java
import com.anthropic.models.organization.federation.rules.RuleListParams;
void main() {
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
var params = RuleListParams.builder()
.issuerId("fdis_01ABCDEFabcdef0123456789XY")
.build();
var rules = client.organization().federation().rules().list(params);
for (var rule : rules.autoPager()) {
IO.println(rule.id() + ": " + rule.name());
}
}
```
```php PHP
$client = new Client();
$rules = $client->organization->federation->rules->list(
issuerID: 'fdis_01ABCDEFabcdef0123456789XY',
);
foreach ($rules->getItems() as $rule) {
echo "{$rule->id}: {$rule->name}\n";
}
```
```ruby Ruby
client = Anthropic::Client.new
rules = client.organization.federation.rules.list(
issuer_id: "fdis_01ABCDEFabcdef0123456789XY"
)
rules.data.each do |rule|
puts "#{rule.id}: #{rule.name}"
end
```
Archiver une règle :
```bash cURL
curl --fail-with-body -sS -X POST "https://api.anthropic.com/v1/organizations/federation_rules/fdrl_01ABCDEFabcdef0123456789XY/archive" \
-H "authorization: Bearer $ANTHROPIC_AUTH_TOKEN" \
-H "anthropic-version: 2023-06-01"
```
```bash CLI
ant organization:federation:rules archive \
--federation-rule-id fdrl_01ABCDEFabcdef0123456789XY
```
```python Python
client = anthropic.Anthropic()
rule = client.organization.federation.rules.archive("fdrl_01ABCDEFabcdef0123456789XY")
print(f"id: {rule.id}")
print(f"archived_at: {rule.archived_at}")
```
```typescript TypeScript
const client = new Anthropic();
const rule = await client.organization.federation.rules.archive(
"fdrl_01ABCDEFabcdef0123456789XY"
);
console.log(`id: ${rule.id}`);
console.log(`archived_at: ${rule.archived_at}`);
```
```csharp C#
AnthropicClient client = new();
var rule = await client.Organization.Federation.Rules.Archive(
"fdrl_01ABCDEFabcdef0123456789XY"
);
Console.WriteLine($"id: {rule.ID}");
Console.WriteLine($"archived_at: {rule.ArchivedAt:O}");
```
```go Go
client := anthropic.NewClient()
rule, err := client.Organization.Federation.Rules.Archive(
context.Background(),
"fdrl_01ABCDEFabcdef0123456789XY",
)
if err != nil {
log.Fatal(err)
}
fmt.Printf("id: %s\n", rule.ID)
fmt.Printf("archived_at: %s\n", rule.ArchivedAt)
```
```java Java
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
var rule = client.organization().federation().rules()
.archive("fdrl_01ABCDEFabcdef0123456789XY");
IO.println("id: " + rule.id());
IO.println("archived_at: " + rule.archivedAt().orElseThrow());
```
```php PHP
$client = new Client();
$rule = $client->organization->federation->rules->archive(
federationRuleID: 'fdrl_01ABCDEFabcdef0123456789XY',
);
echo "id: {$rule->id}\n";
echo "archived_at: {$rule->archivedAt?->format(DATE_ATOM)}\n";
```
```ruby Ruby
client = Anthropic::Client.new
rule_id = "fdrl_01ABCDEFabcdef0123456789XY"
rule = client.organization.federation.rules.archive(rule_id)
puts "id: #{rule.id}"
puts "archived_at: #{rule.archived_at}"
```
Le point de terminaison de liste renvoie une page de règles et le curseur de la page suivante :
```json
{
"data": [{ "id": "fdrl_...", "name": "gha-deploy", "...": "..." }],
"next_page": "..."
}
```
Pour lire ou mettre à jour une règle individuelle, utilisez `GET` et `POST` sur `/v1/organizations/federation_rules/{rule_id}`. Pour gérer les espaces de travail dans lesquels une règle peut émettre des jetons, utilisez `GET` et `POST` sur `/v1/organizations/federation_rules/{rule_id}/workspaces`, et `DELETE` sur `/v1/organizations/federation_rules/{rule_id}/workspaces/{workspace_id}`.
Pour le détail complet des paramètres et les schémas de réponse, consultez la [référence API des règles de fédération](https://platform.claude.com/docs/fr/api/organization/federation/rules).
## Permissions et contraintes
* Les appelants authentifiés par OAuth ne peuvent créer ou modifier que des règles dont l'`oauth_scope` est `workspace:developer` ou `workspace:inference`. Pour créer ou modifier une règle avec toute autre portée (telle que `org:admin` ou `workspace:manage_tunnels`), utilisez la Console.
* Un appelant OAuth ne peut pas mettre à jour un émetteur de fédération qui sous-tend une règle dont l'`oauth_scope` est autre que `workspace:developer` ou `workspace:inference` (telle que `org:admin` ou `workspace:manage_tunnels`). Envisagez d'enregistrer un émetteur dédié pour la règle d'amorçage afin que les émetteurs derrière les règles à portée d'espace de travail restent modifiables via l'API.
* Les clés Admin API ne sont pas acceptées sur ces points de terminaison, ni en lecture ni en écriture ; utilisez un jeton OAuth `org:admin`.
Une règle avec `oauth_scope: org:admin` doit cibler un compte de service dont l'`organization_role` est `admin`. Les noms de ressources doivent correspondre à `^[a-z0-9-]+$`, comporter de 1 à 255 caractères et être uniques au sein d'une organisation pour chaque type de ressource ; pour l'ensemble des contraintes au niveau des champs, voir [Règles de validation](https://platform.claude.com/docs/fr/manage-claude/wif-reference#validation-rules).
## Pagination et archivage
Les points de terminaison de liste des comptes de service, des émetteurs de fédération et des règles de fédération acceptent `limit` (de 1 à 100, 20 par défaut) et un curseur `page` issu de la réponse précédente. Transmettez la valeur `next_page` de la réponse comme paramètre de requête `page` lors de la requête suivante. La liste de la sous-ressource des espaces de travail d'une règle renvoie l'ensemble complet sans pagination. Les ressources archivées sont masquées des listes par défaut ; transmettez `include_archived=true` pour les inclure.
L'archivage est une suppression logique et est idempotent : archiver une ressource déjà archivée réussit. L'archivage d'un émetteur ou d'un compte de service renvoie `400` tant qu'une règle de fédération active y fait encore référence ; archivez d'abord la règle.
## Voir aussi
* [Workload Identity Federation](https://platform.claude.com/docs/fr/manage-claude/workload-identity-federation) : concepts et guide de configuration dans la Console
* [Référence WIF](https://platform.claude.com/docs/fr/manage-claude/wif-reference) : variables d'environnement, règles de validation, portées OAuth et codes d'erreur
* [Admin API](https://platform.claude.com/docs/fr/manage-claude/admin-api) : le reste de la surface de gestion de l'organisation
* [Référence de l'Admin API](https://platform.claude.com/docs/fr/api/organization) : schémas de requête et de réponse générés pour les points de terminaison de comptes de service et de fédération