Configure Anthropic

from keycardai.oauth import Client, BasicAuth
from anthropic import Anthropic, WorkloadIdentityCredentials

# 1. Get a Keycard OIDC token scoped to Anthropic.
with Client(
    "<keycard-issuer-url>",  # from Settings → Connection
    auth=BasicAuth("<your-client-id>", "<your-client-secret>"),
) as kc:
    token = kc.client_credentials_grant(
        resource="https://api.anthropic.com",
    )

# 2. Use it with the Anthropic SDK — WIF exchange happens automatically.
client = Anthropic(
    credentials=WorkloadIdentityCredentials(
        identity_token_provider=lambda: token.access_token,
        federation_rule_id="<fdrl_...>",
        organization_id="<anthropic-org-id>",
        service_account_id="<svac_...>",
        workspace_id="<wrkspc_...>",
    ),
)

message = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Hello from a Keycard workload"}],
)
print(message.content[0].text)

import Anthropic from "@anthropic-ai/sdk";
import { oidcFederationProvider } from "@anthropic-ai/sdk/lib/credentials/oidc-federation";
import { ClientCredentialsClient } from "@keycardai/oauth";

// 1. Get a Keycard OIDC token scoped to Anthropic.
const kc = new ClientCredentialsClient(
  "<keycard-issuer-url>", // from Settings → Connection
  { clientId: "<your-client-id>", clientSecret: "<your-client-secret>" },
);
const keycardToken = await kc.requestToken({
  resource: "https://api.anthropic.com",
});

// 2. Use it with the Anthropic SDK — WIF exchange happens automatically.
const client = new Anthropic({
  credentials: oidcFederationProvider({
    identityTokenProvider: () => keycardToken.accessToken,
    federationRuleId: "<fdrl_...>",
    organizationId: "<anthropic-org-id>",
    serviceAccountId: "<svac_...>",
    workspaceId: "<wrkspc_...>",
    baseURL: "https://api.anthropic.com",
    fetch,
  }),
});

const message = await client.messages.create({
  model: "claude-sonnet-4-6",
  max_tokens: 1024,
  messages: [{ role: "user", content: "Hello from a Keycard workload" }],
});
console.log(message.content[0].text);

package main

import (
  "context"
  "fmt"
  "log"

  "github.com/anthropics/anthropic-sdk-go"
  "github.com/anthropics/anthropic-sdk-go/option"
  "github.com/keycardai/go-sdk/oauth"
)

func main() {
  ctx := context.Background()

  // 1. Get a Keycard OIDC token scoped to Anthropic.
  kc := oauth.NewClientCredentialsClient(
    "<keycard-issuer-url>", // from Settings → Connection
    oauth.WithCCBasicAuth("<your-client-id>", "<your-client-secret>"),
  )

  keycardToken, err := kc.RequestToken(ctx, oauth.ClientCredentialsRequest{
    Resource: "https://api.anthropic.com",
  })
  if err != nil {
    log.Fatal(err)
  }

  // 2. Use it with the Anthropic SDK — WIF exchange happens automatically.
  client := anthropic.NewClient(
    option.WithFederationTokenProvider(
      func(_ context.Context) (string, error) {
        return keycardToken.AccessToken, nil
      },
      option.FederationOptions{
        FederationRuleID: "<fdrl_...>",
        OrganizationID:   "<anthropic-org-id>",
        ServiceAccountID: "<svac_...>",
        WorkspaceID:      "<wrkspc_...>",
      },
    ),
  )

  message, err := client.Messages.New(ctx, anthropic.MessageNewParams{
    Model:     "claude-sonnet-4-6",
    MaxTokens: 1024,
    Messages: []anthropic.MessageParam{
      anthropic.NewUserMessage(anthropic.NewTextBlock("Hello from a Keycard workload")),
    },
  })
  if err != nil {
    log.Fatal(err)
  }
  fmt.Println(message.Content[0].Text)
}

require "anthropic"
require "keycardai/oauth"

# 1. Get a Keycard OIDC token scoped to Anthropic.
kc = Keycardai::OAuth::ClientCredentialsClient.new(
  issuer: "<keycard-issuer-url>", # from Settings → Connection
  client_id: "<your-client-id>",
  client_secret: "<your-client-secret>",
)
keycard_token = kc.request_token(resource: "https://api.anthropic.com")

# 2. Use it with the Anthropic SDK. WIF exchange happens automatically.
client = Anthropic::Client.new(
  credentials: Anthropic::Credentials::WorkloadIdentity.new(
    identity_token_provider: -> { keycard_token.access_token },
    federation_rule_id: "<fdrl_...>",
    organization_id: "<anthropic-org-id>",
    service_account_id: "<svac_...>",
    workspace_id: "<wrkspc_...>",
  ),
)

message = client.messages.create(
  model: "claude-sonnet-4-6",
  max_tokens: 1024,
  messages: [{role: "user", content: "Hello from a Keycard workload"}],
)
puts message.content[0].text