Microsoft Foundry의 Claude

# ant reads ANTHROPIC_API_KEY and sends it as x-api-key, which Foundry accepts
export ANTHROPIC_API_KEY="YOUR_AZURE_API_KEY"

ant messages create \
  --base-url https://example-resource.services.ai.azure.com/anthropic \
  --model claude-opus-5-5 \
  --max-tokens 1024 \
  --message '{role: user, content: "Hello!"}' \
  --transform content

import os
from anthropic import AnthropicFoundry

client = AnthropicFoundry(
    api_key=os.environ.get("ANTHROPIC_FOUNDRY_API_KEY"),
    resource="example-resource",  # your resource name
)

message = client.messages.create(
    model="claude-opus-5-5",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Hello!"}],
)
print(message.content)

import AnthropicFoundry from "@anthropic-ai/foundry-sdk";

const client = new AnthropicFoundry({
  apiKey: proces...KEY,
  resource: "example-resource" // your resource name
});

const message = await client.messages.create({
  model: "claude-opus-5-5",
  max_tokens: 1024,
  messages: [{ role: "user", content: "Hello!" }]
});
console.log(message.content);

using Anthropic.Foundry;
using Anthropic.Models.Messages;

var client = new AnthropicFoundryClient(
    new AnthropicFoundryApiKeyCredentials(
        Environment.GetEnvironmentVariable("ANTHROPIC_FOUNDRY_API_KEY")!,
        "example-resource"
    )
);

var response = await client.Messages.Create(new MessageCreateParams
{
    Model = "claude-opus-5-5",
    MaxTokens = 1024,
    Messages = [new() { Role = Role.User, Content = "Hello!" }],
});

Console.WriteLine(
    string.Join("", response.Content
        .Select(block => block.Value)
        .OfType<TextBlock>()
        .Select(textBlock => textBlock.Text)));

// The Go SDK does not yet support Foundry natively. This example uses the
// standard Go SDK as a workaround. WithoutEnvironmentDefaults keeps the
// client from also reading ANTHROPIC_API_KEY or ANTHROPIC_AUTH_TOKEN from
// the environment and sending a Claude API credential to your Foundry
// endpoint. Features that Foundry does not support fail server-side rather
// than client-side. For full Foundry support, use the C#, Java, PHP,
// Python, or TypeScript SDKs.
package main

import (
	"context"
	"fmt"
	"os"

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

func main() {
	client := anthropic.NewClient(
		option.WithoutEnvironmentDefaults(),
		option.WithBaseURL("https://example-resource.services.ai.azure.com/anthropic"),
		option.WithAPIKey(os.Getenv("ANTHROPIC_FOUNDRY_API_KEY")),
	)

	message, err := client.Messages.New(context.Background(), anthropic.MessageNewParams{
		Model:     "claude-opus-5-5",
		MaxTokens: 1024,
		Messages: []anthropic.MessageParam{
			anthropic.NewUserMessage(anthropic.NewTextBlock("Hello!")),
		},
	})
	if err != nil {
		panic(err)
	}
	fmt.Println(message.Content)
}

import com.anthropic.client.AnthropicClient;
import com.anthropic.client.okhttp.AnthropicOkHttpClient;
import com.anthropic.foundry.backends.FoundryBackend;
import com.anthropic.models.messages.MessageCreateParams;

void main() {
    // Requires env vars: ANTHROPIC_FOUNDRY_API_KEY, ANTHROPIC_FOUNDRY_RESOURCE
    AnthropicClient client = AnthropicOkHttpClient.builder()
        .backend(FoundryBackend.fromEnv())
        .build();

    MessageCreateParams params = MessageCreateParams.builder()
        .model("claude-opus-5-5")
        .maxTokens(1024)
        .addUserMessage("Hello!")
        .build();

    client.messages().create(params).content().stream()
        .flatMap(block -> block.text().stream())
        .forEach(textBlock -> IO.println(textBlock.text()));
}

use Anthropic\Foundry;

$client = Foundry\Client::withCredentials(
    apiKey: getenv...Y'),
    baseUrl: 'https://example-resource.services.ai.azure.com/anthropic',
);

$message = $client->messages->create(
    maxTokens: 1024,
    messages: [
        ['role' => 'user', 'content' => 'Hello!']
    ],
    model: 'claude-opus-5-5',
);
echo array_find($message->content, fn ($block) => $block->type === 'text')->text;

# The Ruby SDK does not yet support Foundry natively. This example uses the
# standard Ruby SDK as a workaround. Pass credentials explicitly: without
# them, the client falls back to the ANTHROPIC_API_KEY or
# ANTHROPIC_AUTH_TOKEN environment variables and could send a Claude API
# credential to your Foundry endpoint. Features that Foundry
# does not support fail server-side rather than client-side. For full
# Foundry support, use the C#, Java, PHP, Python, or TypeScript SDKs.
require "anthropic"

client = Anthropic::Client.new(
  base_url: "https://example-resource.services.ai.azure.com/anthropic",
  api_key: ENV.fetch("ANTHROPIC_FOUNDRY_API_KEY")
)

message = client.messages.create(
  model: "claude-opus-5-5",
  max_tokens: 1024,
  messages: [{role: "user", content: "Hello!"}]
)

puts message.content.find { it.type == :text }.text

Make request with token. Replace {resource} with your resource name

curl https://{resource}.services.ai.azure.com/anthropic/v1/messages
-H "content-type: application/json"
-H "Authorization: Bearer ***"
-H "anthropic-version: 2023-06-01"
-d '{ "model": "claude-opus-5-5", "max_tokens": 1024, "messages": [ {"role": "user", "content": "Hello!"} ] }'

```bash CLI
# The ant CLI can send a bearer token with --auth-token, but a set
# ANTHROPIC_API_KEY environment variable takes precedence over it (the CLI
# prints only a console notice), so your request could authenticate with
# the wrong credential. For the Entra ID flow, use the cURL example or one
# of the SDK examples instead.

from anthropic import AnthropicFoundry
from azure.identity import DefaultAzureCredential, get_bearer_token_provider

# Get Microsoft Entra ID token using token provider pattern
token_provider = get_bearer_token_provider(
    DefaultAzureCredential(), "https://ai.azure.com/.default"
)

# Create client with Entra ID authentication
client = AnthropicFoundry(
    resource="example-resource",  # your resource name
    azure_ad_token_provider=token_provider,  # Use token provider for Entra ID auth
)

# Make request
message = client.messages.create(
    model="claude-opus-5-5",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Hello!"}],
)
print(message.content)

import AnthropicFoundry from "@anthropic-ai/foundry-sdk";
import { DefaultAzureCredential, getBearerTokenProvider } from "@azure/identity";

// Get Entra ID token using token provider pattern
const credential = new DefaultAzureCredential();
const tokenProvider = getBearerTokenProvider(credential, "https://ai.azure.com/.default");

// Create client with Entra ID authentication
const client = new AnthropicFoundry({
  resource: "example-resource", // your resource name
  azureADTokenProvider: tokenProvider // Use token provider for Entra ID auth
});

// Make request
const message = await client.messages.create({
  model: "claude-opus-5-5",
  max_tokens: 1024,
  messages: [{ role: "user", content: "Hello!" }]
});
console.log(message.content);

using Anthropic.Foundry;
using Anthropic.Models.Messages;
using Azure.Identity;

var client = new AnthropicFoundryClient(
    new AnthropicFoundryIdentityTokenCredentials(
        new DefaultAzureCredential(),
        "example-resource"
    )
);

var response = await client.Messages.Create(new MessageCreateParams
{
    Model = "claude-opus-5-5",
    MaxTokens = 1024,
    Messages = [new() { Role = Role.User, Content = "Hello!" }],
});

Console.WriteLine(
    string.Join("", response.Content
        .Select(block => block.Value)
        .OfType<TextBlock>()
        .Select(textBlock => textBlock.Text)));

// The Go SDK does not yet support Foundry natively. This example uses the
// standard Go SDK as a workaround, with a static Entra ID token: automatic
// token refresh is not built in, so your application must refresh tokens
// itself (they typically expire after 1 hour). WithoutEnvironmentDefaults
// keeps the client from also reading ANTHROPIC_API_KEY or
// ANTHROPIC_AUTH_TOKEN from the environment and sending a Claude API
// credential to your Foundry endpoint. For full Foundry support, use the
// C#, Java, PHP, Python, or TypeScript SDKs.
package main

import (
	"context"
	"fmt"
	"os"

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

func main() {
	// Obtain an Entra ID access token, for example using the Azure CLI:
	//   az account get-access-token --resource https://ai.azure.com \
	//     --query accessToken -o tsv
	client := anthropic.NewClient(
		option.WithoutEnvironmentDefaults(),
		option.WithBaseURL("https://example-resource.services.ai.azure.com/anthropic"),
		option.WithAuthToken(os.Getenv("AZURE_ACCESS_TOKEN")),
	)

	message, err := client.Messages.New(context.Background(), anthropic.MessageNewParams{
		Model:     "claude-opus-5-5",
		MaxTokens: 1024,
		Messages: []anthropic.MessageParam{
			anthropic.NewUserMessage(anthropic.NewTextBlock("Hello!")),
		},
	})
	if err != nil {
		panic(err)
	}
	fmt.Println(message.Content)
}

import com.anthropic.client.AnthropicClient;
import com.anthropic.client.okhttp.AnthropicOkHttpClient;
import com.anthropic.foundry.backends.FoundryBackend;
import com.anthropic.models.messages.MessageCreateParams;
import com.azure.identity.AuthenticationUtil;
import com.azure.identity.DefaultAzureCredentialBuilder;
import java.util.function.Supplier;

void main() {
    Supplier<String> bearerTokenSupplier = AuthenticationUtil.getBearerTokenSupplier(
        new DefaultAzureCredentialBuilder().build(),
        "https://ai.azure.com/.default"
    );

    AnthropicClient client = AnthropicOkHttpClient.builder()
        .backend(FoundryBackend.builder()
            .bearerTokenSupplier(bearerTokenSupplier)
            .resource("example-resource")
            .build())
        .build();

    MessageCreateParams params = MessageCreateParams.builder()
        .model("claude-opus-5-5")
        .maxTokens(1024)
        .addUserMessage("Hello!")
        .build();

    client.messages().create(params).content().stream()
        .flatMap(block -> block.text().stream())
        .forEach(textBlock -> IO.println(textBlock.text()));
}

use Anthropic\Foundry;

// Obtain an Entra ID access token, for example using the Azure CLI:
//   az account get-access-token --resource https://ai.azure.com \
//     --query accessToken -o tsv
$token = getenv('AZURE_ACCESS_TOKEN');

$client = Foundry\Client::withCredentials(
    authToken: $token,
    baseUrl: 'https://example-resource.services.ai.azure.com/anthropic',
);

$message = $client->messages->create(
    maxTokens: 1024,
    messages: [
        ['role' => 'user', 'content' => 'Hello!']
    ],
    model: 'claude-opus-5-5',
);
echo array_find($message->content, fn ($block) => $block->type === 'text')->text;

# The Ruby SDK does not yet support Foundry natively. This example uses the
# standard Ruby SDK as a workaround, with a static Entra ID token: automatic
# token refresh is not built in, so your application must refresh tokens
# itself (they typically expire after 1 hour). Pass credentials explicitly:
# without them, the client falls back to the ANTHROPIC_API_KEY or
# ANTHROPIC_AUTH_TOKEN environment variables. For full Foundry support, use
# the C#, Java, PHP, Python, or TypeScript SDKs.
require "anthropic"

# Obtain an Entra ID access token, for example using the Azure CLI:
#   az account get-access-token --resource https://ai.azure.com \
#     --query accessToken -o tsv
client = Anthropic::Client.new(
  base_url: "https://example-resource.services.ai.azure.com/anthropic",
  auth_token: ENV.fetch("AZURE_ACCESS_TOKEN")
)

message = client.messages.create(
  model: "claude-opus-5-5",
  max_tokens: 1024,
  messages: [{role: "user", content: "Hello!"}]
)

puts message.content.find { it.type == :text }.text