---
title: Administra WIF con la Admin API
url: https://platform.claude.com/docs/es/manage-claude/wif-admin-api
description: Crea y administra cuentas de servicio, emisores y reglas de Workload Identity Federation de forma programática para flujos de trabajo de infraestructura como código y CI.
---
La Admin API te permite crear y administrar recursos de [Workload Identity Federation](https://platform.claude.com/docs/es/manage-claude/workload-identity-federation) de forma programática: cuentas de servicio, emisores de federación y reglas de federación. Úsala para mantener tu configuración de federación en infraestructura como código, aprovisionarla desde CI y reproducirla en distintas organizaciones en lugar de hacer clic en la Claude Console. Estos endpoints comparten el prefijo de ruta `/v1/organizations` con el resto de la [Admin API](https://platform.claude.com/docs/es/manage-claude/admin-api).
## Requisitos previos
Cada solicitud en esta página se autentica con un token de portador OAuth que incluye el alcance `org:admin`. El alcance se otorga solo a los miembros de la organización con el rol de administrador, propietario o propietario principal, y otorga acceso a toda la organización: cualquier vinculación a un espacio de trabajo se ignora. Hay dos formas de obtener un token, y tienen permisos diferentes: un token de tu propio inicio de sesión actúa como un usuario, mientras que un token federado actúa como una cuenta de servicio y no puede realizar todas las operaciones de esta página.
### Interactivo (tu terminal)
Inicia sesión con la [CLI `ant`](https://platform.claude.com/docs/es/cli-sdks-libraries/cli/quickstart) bajo un perfil dedicado, solicitando el alcance `org:admin` (consulta [Acceso de administrador](https://platform.claude.com/docs/es/cli-sdks-libraries/cli/authentication#admin-access)), y luego exporta el token de portador. Iniciar sesión con `--profile admin` almacena la credencial `org:admin` bajo su propio nombre de perfil y también la convierte en el perfil activo de la CLI, y la variable exportada se aplica a cada llamada del SDK y de la CLI en esa shell; así que usa una shell que reserves para la administración, elimina la variable cuando termines y vuelve a cambiar la CLI con `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)
```
Los tokens interactivos son de corta duración; si las solicitudes empiezan a devolver 401, vuelve a ejecutar el comando de exportación (actualiza el token automáticamente).
Los SDK y la CLI `ant` leen `ANTHROPIC_AUTH_TOKEN` automáticamente; deja `ANTHROPIC_API_KEY` sin definir en la misma shell, porque estos endpoints rechazan las claves de API y todos los clientes usan la clave cuando ambas están definidas.
### Workload (CI y automatización)
Crea una regla de federación con `oauth_scope: org:admin` que apunte a una cuenta de servicio cuyo `organization_role` sea `admin`. La regla en sí debe crearse en la Claude Console: otorgar a un workload acceso de administrador de la organización es una acción humana deliberada, no algo que la automatización pueda iniciar por sí misma. La siguiente sección explica esta configuración que se realiza una vez por organización.
## Inicializa un workload para administrar WIF
Una sola regla creada en la Console es suficiente para poner el resto de tu configuración de federación bajo infraestructura como código: otorga a un único workload de confianza el alcance `org:admin` y deja que ese workload administre los emisores de federación y todas las reglas de federación con alcance de espacio de trabajo a través de esta API.
En la Claude Console, ve a la página [Workload identity](https://platform.claude.com/settings/workload-identity-federation) (`platform.claude.com/settings/workload-identity-federation`) y selecciona **Connect workload** para crear una regla de federación para tu workload de automatización, por ejemplo un flujo de trabajo de GitHub Actions en tu repositorio de infraestructura. En **Advanced rule options**, establece el alcance OAuth de la regla en `org:admin`: el asistente crea entonces la nueva cuenta de servicio con el rol de organización Admin (o te pide que elijas una cuenta de servicio de administrador existente como destino).
Haz que la regla coincida con una identidad de workload exacta, no con un patrón amplio. `subject_prefix` es una coincidencia exacta a menos que termine en `*`. Para GitHub Actions, fija el sujeto a una rama protegida, como `repo:my-org/my-repo:ref:refs/heads/main`. Un comodín final como `repo:my-org/my-repo:*` también coincide con ejecuciones de `pull_request`, incluidas las ejecuciones activadas desde forks, por lo que cualquiera que pudiera abrir un pull request contra el repositorio podría emitir un token `org:admin`. Consulta [Restringe qué flujos de trabajo pueden autenticarse](https://platform.claude.com/docs/es/manage-claude/wif-providers/github-actions#restrict-which-workflows-can-authenticate).
Un workload que usa uno de los SDK o la CLI `ant` no realiza el intercambio por sí mismo. Apunta el cliente a la regla con las variables de entorno de federación y constrúyelo sin argumentos, exactamente como para la inferencia en [Construye el cliente del SDK](https://platform.claude.com/docs/es/manage-claude/workload-identity-federation#construct-the-sdk-client); el cliente intercambia el token de identidad en la primera solicitud y, antes de que expire el token de acceso resultante, vuelve a leer el token de identidad y lo intercambia de nuevo:
```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 solo es obligatorio si la regla está habilitada para todos
# los espacios de trabajo o más de uno; los endpoints org:admin ignoran la vinculación.
unset ANTHROPIC_API_KEY ANTHROPIC_AUTH_TOKEN # both take precedence over federation
```
La CLI `ant` lee las mismas variables, o acepta los flags `--federation-rule`, `--organization-id`, `--service-account-id` e `--identity-token-file`. Para un workload que ejecuta más de un comando `ant`, usa un [perfil de federación](https://platform.claude.com/docs/es/manage-claude/wif-reference#profile-configuration-file) en lugar de flags o variables de entorno: con flags o variables, la CLI intercambia el token de identidad de nuevo en cada proceso, y los tokens de identidad que incluyen un claim `jti` (los tokens de GitHub Actions lo incluyen) se aceptan solo una vez, por lo que un segundo comando sería rechazado; un perfil es también la única forma de darle a la CLI un `workspace_id` para el intercambio cuando la regla está habilitada para todos los espacios de trabajo o para más de uno, porque, a diferencia de los SDK, la CLI no pasa `ANTHROPIC_WORKSPACE_ID` ni `--workspace-id` al intercambio. Cada SDK también acepta la misma configuración como argumentos explícitos del constructor, que se muestran por lenguaje en [Construye el cliente del SDK](https://platform.claude.com/docs/es/manage-claude/workload-identity-federation#construct-the-sdk-client). Consulta [Variables de entorno](https://platform.claude.com/docs/es/manage-claude/wif-reference#environment-variables) y [Precedencia de credenciales](https://platform.claude.com/docs/es/manage-claude/wif-reference#credential-precedence) para ver la lista completa y el orden.
Un workload que llama a la API con curl intercambia por sí mismo el JWT por un token de portador `org:admin` de corta duración, usando el mismo [intercambio de tokens](https://platform.claude.com/docs/es/manage-claude/workload-identity-federation#authenticate-from-your-workload) que cualquier otro workload federado, y lo envía en el encabezado `authorization: Bearer`.
Con el cliente configurado (o, para curl, el token emitido en `ANTHROPIC_AUTH_TOKEN`), el workload crea y administra tu configuración de federación usando los endpoints de esta página.
Para conocer las operaciones que un token emitido por un workload puede y no puede realizar, consulta [Permisos y restricciones](https://platform.claude.com/docs/es/manage-claude/wif-admin-api#permissions-and-constraints). Si ya creaste emisores, cuentas de servicio o reglas con el asistente **Connect workload**, enuméralos con los siguientes endpoints e impórtalos en tu estado de infraestructura como código en lugar de volver a crearlos.
## Autenticación
Todos los endpoints se encuentran bajo `https://api.anthropic.com/v1/organizations/`. Cada solicitud a los endpoints de federación y de cuentas de servicio necesita el encabezado de versión de la API y el token de portador:
En los SDK, estos endpoints son `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`) y `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` y `federation:rules` en la CLI). Los ejemplos del SDK y de la CLI construyen el cliente predeterminado, que envía el token de portador desde `ANTHROPIC_AUTH_TOKEN` o, en un workload automatizado, realiza el intercambio de federación por sí mismo como se describe en [Inicializa un workload para administrar WIF](https://platform.claude.com/docs/es/manage-claude/wif-admin-api#bootstrap-a-workload-to-manage-wif). Los métodos de listado del SDK obtienen páginas adicionales bajo demanda, por lo que `limit` establece el tamaño de página; los ejemplos de PHP y Ruby leen una página.
```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
```
Las claves de la Admin API no se aceptan en estos endpoints; los ejemplos con `x-api-key` de la página de la Admin API no se aplican aquí.
## Cuentas de servicio
Una [cuenta de servicio](https://platform.claude.com/docs/es/manage-claude/workload-identity-federation#service-accounts) (`svac_...`) es la identidad no humana como la que actúa un token federado. Establece `organization_role` en `developer`.
Crea una cuenta de servicio:
```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}"
```
Enumera las cuentas de servicio:
```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
```
Archiva una cuenta de servicio:
```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}"
```
El endpoint de creación devuelve la nueva cuenta de servicio:
```json
{
"id": "svac_...",
"name": "inference-worker",
"organization_role": "developer",
"created_at": "...",
"type": "service_account",
"...": "..."
}
```
Para leer o actualizar una sola cuenta de servicio, usa `GET` y `POST` en `/v1/organizations/service_accounts/{service_account_id}`. Una cuenta de servicio debe ser miembro de un espacio de trabajo antes de que los tokens federados puedan actuar en él. Cada cuenta de servicio tiene una membresía implícita en el espacio de trabajo predeterminado de tu organización; agrega membresías explícitas para otros espacios de trabajo con `GET`, `POST` y `DELETE` en `/v1/organizations/service_accounts/{service_account_id}/workspaces`, donde `DELETE` apunta a `.../workspaces/{workspace_id}`.
Para obtener detalles completos de los parámetros y los esquemas de respuesta, consulta la [referencia de la API de cuentas de servicio](https://platform.claude.com/docs/es/api/organization/service_accounts).
## Emisores de federación
Un [emisor de federación](https://platform.claude.com/docs/es/manage-claude/workload-identity-federation#federation-issuers) (`fdis_...`) registra un proveedor de identidad OIDC en tu organización. El campo `jwks` es una unión discriminada que controla cómo Anthropic obtiene las claves de firma del proveedor:
| Valor de `jwks` | Cuándo usarlo |
| ---------------------------------------- | ----------------------------------------------------------------------------------------- |
| `{"type": "discovery"}` | El proveedor sirve `/.well-known/openid-configuration` en la URL del emisor. |
| `{"type": "explicit_url", "url": "..."}` | Apunta directamente a un endpoint JWKS. |
| `{"type": "inline", "keys": [...]}` | Sube el conjunto de claves para proveedores que no son accesibles desde internet pública. |
Registra un emisor. Este ejemplo registra GitHub Actions con descubrimiento de 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}"
```
Enumera los emisores:
```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
```
Archiva un emisor:
```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}"
```
Para leer o actualizar un solo emisor, usa `GET` y `POST` en `/v1/organizations/federation_issuers/{issuer_id}`. Un llamador OAuth no puede actualizar un emisor que respalda una regla cuyo `oauth_scope` sea distinto de `workspace:developer` o `workspace:inference`; consulta [Permisos y restricciones](https://platform.claude.com/docs/es/manage-claude/wif-admin-api#permissions-and-constraints).
Para obtener detalles completos de los parámetros y los esquemas de respuesta, consulta la [referencia de la API de emisores de federación](https://platform.claude.com/docs/es/api/organization/federation/issuers).
## Reglas de federación
Una [regla de federación](https://platform.claude.com/docs/es/manage-claude/workload-identity-federation#federation-rules) (`fdrl_...`) vincula un emisor a una cuenta de servicio: los JWT del emisor que cumplen las condiciones de coincidencia de la regla pueden emitir tokens que actúan como el destino de la regla. El `workspace_id` en la solicitud de creación habilita la regla en ese espacio de trabajo al crearla; agrega más espacios de trabajo más adelante a través del subrecurso `/federation_rules/{rule_id}/workspaces`. Se requiere `workspace_id` o `applies_to_all_workspaces: true` al crearla.
Crea una regla. Este ejemplo permite que los despliegues de GitHub Actions desde la rama main actúen como la cuenta de servicio:
```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}"
```
Enumera las reglas, opcionalmente filtradas por emisor:
```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
```
Archiva una regla:
```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}"
```
El endpoint de listado devuelve una página de reglas y el cursor para la página siguiente:
```json
{
"data": [{ "id": "fdrl_...", "name": "gha-deploy", "...": "..." }],
"next_page": "..."
}
```
Para leer o actualizar una sola regla, usa `GET` y `POST` en `/v1/organizations/federation_rules/{rule_id}`. Para administrar los espacios de trabajo en los que una regla puede emitir tokens, usa `GET` y `POST` en `/v1/organizations/federation_rules/{rule_id}/workspaces`, y `DELETE` en `/v1/organizations/federation_rules/{rule_id}/workspaces/{workspace_id}`.
Para obtener detalles completos de los parámetros y los esquemas de respuesta, consulta la [referencia de la API de reglas de federación](https://platform.claude.com/docs/es/api/organization/federation/rules).
## Permisos y restricciones
* Los llamadores autenticados con OAuth solo pueden crear o modificar reglas cuyo `oauth_scope` sea `workspace:developer` o `workspace:inference`. Para crear o modificar una regla con cualquier otro alcance (como `org:admin` o `workspace:manage_tunnels`), usa la Console.
* Un llamador OAuth no puede actualizar un emisor de federación que respalda una regla cuyo `oauth_scope` sea distinto de `workspace:developer` o `workspace:inference` (como `org:admin` o `workspace:manage_tunnels`). Considera registrar un emisor dedicado para la regla de inicialización, de modo que los emisores detrás de las reglas con alcance de espacio de trabajo sigan siendo actualizables a través de la API.
* Las claves de la Admin API no se aceptan en estos endpoints, ni para lecturas ni para escrituras; usa un token OAuth `org:admin`.
Una regla con `oauth_scope: org:admin` debe apuntar a una cuenta de servicio cuyo `organization_role` sea `admin`. Los nombres de los recursos deben coincidir con `^[a-z0-9-]+$`, tener entre 1 y 255 caracteres y ser únicos dentro de una organización para cada tipo de recurso; para conocer todas las restricciones a nivel de campo, consulta [Reglas de validación](https://platform.claude.com/docs/es/manage-claude/wif-reference#validation-rules).
## Paginación y archivado
Los endpoints de listado de cuentas de servicio, emisores de federación y reglas de federación aceptan `limit` (de 1 a 100, 20 de forma predeterminada) y un cursor `page` tomado de la respuesta anterior. Pasa el valor `next_page` de la respuesta como el parámetro de consulta `page` en la siguiente solicitud. El listado del subrecurso de espacios de trabajo de reglas devuelve el conjunto completo sin paginación. Los recursos archivados se ocultan de los listados de forma predeterminada; pasa `include_archived=true` para incluirlos.
El archivado es una eliminación lógica y es idempotente: archivar un recurso ya archivado se completa correctamente. Archivar un emisor o una cuenta de servicio devuelve `400` mientras una regla de federación activa todavía haga referencia a él; archiva primero la regla.
## Consulta también
* [Workload Identity Federation](https://platform.claude.com/docs/es/manage-claude/workload-identity-federation): conceptos y el recorrido de configuración en la Console
* [Referencia de WIF](https://platform.claude.com/docs/es/manage-claude/wif-reference): variables de entorno, reglas de validación, alcances OAuth y códigos de error
* [Admin API](https://platform.claude.com/docs/es/manage-claude/admin-api): el resto de la superficie de administración de la organización
* [Referencia de la Admin API](https://platform.claude.com/docs/es/api/organization): esquemas de solicitud y respuesta generados para los endpoints de cuentas de servicio y de federación