> ## Documentation Index
> Fetch the complete documentation index at: https://www.edgee.ai/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Anthropic SDK

> Use Edgee with the Anthropic SDK for building AI applications with Claude models.

The Anthropic SDK provides official Python and TypeScript clients for interacting with Claude models. Edgee's Anthropic-compatible API
works seamlessly with the Anthropic SDK, allowing you to leverage the SDK's features while gaining access to
Edgee's unified gateway, automatic failover, and full observability.

## Installation

<Tabs>
  <Tab title="Python">
    ```bash theme={"dark"}
    pip install anthropic
    ```
  </Tab>

  <Tab title="TypeScript">
    ```bash theme={"dark"}
    npm install @anthropic-ai/sdk
    ```
  </Tab>
</Tabs>

## Basic Usage

<Tabs>
  <Tab title="Python">
    ```python theme={"dark"}
    import os
    from anthropic import Anthropic

    # Initialize client with Edgee endpoint
    client = Anthropic(
        base_url="https://api.edgee.ai",
        api_key=os.environ.get("EDGEE_API_KEY"),
    )

    # Send a message
    message = client.messages.create(
        model="claude-sonnet-4.5",
        max_tokens=1024,
        messages=[
            {"role": "user", "content": "What is the capital of France?"}
        ]
    )

    print(message.content)

    # Access token usage
    print(f"Input tokens: {message.usage.input_tokens}")
    print(f"Output tokens: {message.usage.output_tokens}")
    ```
  </Tab>

  <Tab title="TypeScript">
    ```typescript theme={"dark"}
    import Anthropic from '@anthropic-ai/sdk';

    // Initialize client with Edgee endpoint
    const client = new Anthropic({
      baseURL: 'https://api.edgee.ai',
      apiKey: process.env.EDGEE_API_KEY,
    });

    // Send a message
    const message = await client.messages.create({
      model: 'claude-sonnet-4.5',
      max_tokens: 1024,
      messages: [
        { role: 'user', content: 'What is the capital of France?' }
      ]
    });

    console.log(message.content);

    // Access token usage
    console.log(`Input tokens: ${message.usage.input_tokens}`);
    console.log(`Output tokens: ${message.usage.output_tokens}`);
    ```
  </Tab>
</Tabs>

## Streaming Responses

Stream responses for real-time token delivery:

<Tabs>
  <Tab title="Python">
    ```python theme={"dark"}
    from anthropic import Anthropic

    client = Anthropic(
        base_url="https://api.edgee.ai",
        api_key=os.environ.get("EDGEE_API_KEY"),
    )

    # Stream messages
    with client.messages.stream(
        model="claude-sonnet-4.5",
        max_tokens=1024,
        messages=[
            {"role": "user", "content": "Write a short poem about coding"}
        ]
    ) as stream:
        for text in stream.text_stream:
            print(text, end="", flush=True)
    ```
  </Tab>

  <Tab title="TypeScript">
    ```typescript theme={"dark"}
    import Anthropic from '@anthropic-ai/sdk';

    const client = new Anthropic({
      baseURL: 'https://api.edgee.ai',
      apiKey: process.env.EDGEE_API_KEY,
    });

    // Stream messages
    const stream = await client.messages.create({
      model: 'claude-sonnet-4.5',
      max_tokens: 1024,
      messages: [
        { role: 'user', content: 'Write a short poem about coding' }
      ],
      stream: true,
    });

    for await (const event of stream) {
      if (event.type === 'content_block_delta'
          && event.delta.type === 'text_delta') {
        process.stdout.write(event.delta.text);
      }
    }
    ```
  </Tab>
</Tabs>

## Token Usage Tracking

Access standard Anthropic token usage metrics in every response:

<Tabs>
  <Tab title="Python">
    ```python theme={"dark"}
    from anthropic import Anthropic

    client = Anthropic(
        base_url="https://api.edgee.ai",
        api_key=os.environ.get("EDGEE_API_KEY"),
    )

    message = client.messages.create(
        model="claude-sonnet-4.5",
        max_tokens=1024,
        messages=[{"role": "user", "content": "Analyze this long document..."}]
    )

    print(message.content)
    print(f"Input tokens: {message.usage.input_tokens}")
    print(f"Output tokens: {message.usage.output_tokens}")
    ```
  </Tab>

  <Tab title="TypeScript">
    ```typescript theme={"dark"}
    import Anthropic from '@anthropic-ai/sdk';

    const client = new Anthropic({
      baseURL: 'https://api.edgee.ai',
      apiKey: process.env.EDGEE_API_KEY,
    });

    const message = await client.messages.create({
      model: 'claude-sonnet-4.5',
      max_tokens: 1024,
      messages: [{ role: 'user', content: 'Analyze this long document...' }]
    });

    console.log(message.content);
    console.log(`Input tokens: ${message.usage.input_tokens}`);
    console.log(`Output tokens: ${message.usage.output_tokens}`);
    ```
  </Tab>
</Tabs>

<Note>
  When compression is enabled, `input_tokens` reflects the compressed token count. View detailed compression metrics in the [Edgee dashboard](/features/observability).
</Note>

## Compression & Tags via Headers

When using the Anthropic SDK with Edgee, you can control token compression and add tags using HTTP headers:

### Enabling Compression

<Note>
  The headers below control **Token Compression**.
</Note>

<Tabs>
  <Tab title="Python">
    ```python theme={"dark"}
    from anthropic import Anthropic

    client = Anthropic(
        base_url="https://api.edgee.ai",
        api_key=os.environ.get("EDGEE_API_KEY"),
        default_headers={
            "x-edgee-compression-model": "claude",
        }
    )

    # All requests will use Claude Token Compression strategy
    message = client.messages.create(
        model="claude-sonnet-4.5",
        max_tokens=1024,
        messages=[{"role": "user", "content": "Analyze this document..."}]
    )
    ```
  </Tab>

  <Tab title="TypeScript">
    ```typescript theme={"dark"}
    import Anthropic from '@anthropic-ai/sdk';

    const client = new Anthropic({
      baseURL: 'https://api.edgee.ai',
      apiKey: process.env.EDGEE_API_KEY,
      defaultHeaders: {
        'x-edgee-compression-model': 'claude',
      }
    });

    // All requests will use Claude Token Compression strategy
    const message = await client.messages.create({
      model: 'claude-sonnet-4.5',
      max_tokens: 1024,
      messages: [{ role: 'user', content: 'Analyze this document...' }]
    });
    ```
  </Tab>
</Tabs>

### Adding Tags for Analytics

Combine compression with tags to track requests in your dashboard:

<Tabs>
  <Tab title="Python">
    ```python theme={"dark"}
    from anthropic import Anthropic

    client = Anthropic(
        base_url="https://api.edgee.ai",
        api_key=os.environ.get("EDGEE_API_KEY"),
        default_headers={
            "x-edgee-tags": "production,anthropic-sdk,user-123"
        }
    )
    ```
  </Tab>

  <Tab title="TypeScript">
    ```typescript theme={"dark"}
    import Anthropic from '@anthropic-ai/sdk';

    const client = new Anthropic({
      baseURL: 'https://api.edgee.ai',
      apiKey: process.env.EDGEE_API_KEY,
      defaultHeaders: {
        'x-edgee-tags': 'production,anthropic-sdk,user-123'
      }
    });
    ```
  </Tab>
</Tabs>

**Available Headers:**

| Header                      | Type                                            | Description                                                              |
| --------------------------- | ----------------------------------------------- | ------------------------------------------------------------------------ |
| `x-edgee-compression-model` | `"claude"`, `"opencode"`, `"cursor"`, `"codex"` | Compression bundle to apply (e.g. "claude" for Claude Token Compression) |
| `x-edgee-tags`              | `string`                                        | Comma-separated tags for analytics and filtering                         |

<Tip>
  You can also enable compression per API key or Agent in the Edgee console. Headers override console settings for specific requests.
</Tip>

## Multi-Provider Access

With Edgee, you can access models from multiple providers using the same Anthropic SDK client and compare costs across providers:

<Tabs>
  <Tab title="Python">
    ```python theme={"dark"}
    from anthropic import Anthropic

    client = Anthropic(
        base_url="https://api.edgee.ai",
        api_key=os.environ.get("EDGEE_API_KEY"),
    )

    # Use Claude
    claude_response = client.messages.create(
        model="claude-sonnet-4.5",
        max_tokens=1024,
        messages=[{"role": "user", "content": "Hello!"}]
    )

    # Use GPT-4 through the same client
    gpt_response = client.messages.create(
        model="gpt-5.2",
        max_tokens=1024,
        messages=[{"role": "user", "content": "Hello!"}]
    )

    # Use Mistral
    mistral_response = client.messages.create(
        model="mistral-large",
        max_tokens=1024,
        messages=[{"role": "user", "content": "Hello!"}]
    )
    ```
  </Tab>

  <Tab title="TypeScript">
    ```typescript theme={"dark"}
    import Anthropic from '@anthropic-ai/sdk';

    const client = new Anthropic({
      baseURL: 'https://api.edgee.ai/',
      apiKey: process.env.EDGEE_API_KEY,
    });

    // Use Claude
    const claudeResponse = await client.messages.create({
      model: 'claude-sonnet-4.5',
      max_tokens: 1024,
      messages: [{ role: 'user', content: 'Hello!' }]
    });

    // Use GPT-4 through the same client
    const gptResponse = await client.messages.create({
      model: 'gpt-5.2',
      max_tokens: 1024,
      messages: [{ role: 'user', content: 'Hello!' }]
    });

    // Use Mistral
    const mistralResponse = await client.messages.create({
      model: 'mistral-large',
      max_tokens: 1024,
      messages: [{ role: 'user', content: 'Hello!' }]
    });
    ```
  </Tab>
</Tabs>

## Function Calling (Tools)

Use Claude's tool calling with Edgee:

<Tabs>
  <Tab title="Python">
    ```python theme={"dark"}
    from anthropic import Anthropic

    client = Anthropic(
        base_url="https://api.edgee.ai",
        api_key=os.environ.get("EDGEE_API_KEY"),
    )

    # Define a tool
    tools = [
        {
            "name": "get_weather",
            "description": "Get the current weather in a given location",
            "input_schema": {
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "The city and state, e.g. San Francisco, CA"
                    }
                },
                "required": ["location"]
            }
        }
    ]

    # Send message with tools
    message = client.messages.create(
        model="claude-sonnet-4.5",
        max_tokens=1024,
        tools=tools,
        messages=[
            {"role": "user", "content": "What's the weather like in Paris?"}
        ]
    )

    print(message.content)
    ```
  </Tab>

  <Tab title="TypeScript">
    ```typescript theme={"dark"}
    import Anthropic from '@anthropic-ai/sdk';

    const client = new Anthropic({
      baseURL: 'https://api.edgee.ai',
      apiKey: process.env.EDGEE_API_KEY,
    });

    // Define a tool
    const tools = [
      {
        name: 'get_weather',
        description: 'Get the current weather in a given location',
        input_schema: {
          type: 'object',
          properties: {
            location: {
              type: 'string',
              description: 'The city and state, e.g. San Francisco, CA'
            }
          },
          required: ['location']
        }
      }
    ];

    // Send message with tools
    const message = await client.messages.create({
      model: 'claude-sonnet-4.5',
      max_tokens: 1024,
      tools: tools,
      messages: [
        { role: 'user', content: "What's the weather like in Paris?" }
      ]
    });

    console.log(message.content);
    ```
  </Tab>
</Tabs>

## Error Handling and Retries

The Anthropic SDK includes built-in retry logic, which works seamlessly with Edgee's automatic failover:

<Tabs>
  <Tab title="Python">
    ```python theme={"dark"}
    from anthropic import Anthropic, APIError

    client = Anthropic(
        base_url="https://api.edgee.ai",
        api_key=os.environ.get("EDGEE_API_KEY"),
        max_retries=3,  # SDK will retry up to 3 times
    )

    try:
        message = client.messages.create(
            model="claude-sonnet-4.5",
            max_tokens=1024,
            messages=[{"role": "user", "content": "Hello!"}]
        )
        print(message.content)
    except APIError as e:
        print(f"API Error: {e}")
    ```
  </Tab>

  <Tab title="TypeScript">
    ```typescript theme={"dark"}
    import Anthropic from '@anthropic-ai/sdk';

    const client = new Anthropic({
      baseURL: 'https://api.edgee.ai',
      apiKey: process.env.EDGEE_API_KEY,
      maxRetries: 3,  // SDK will retry up to 3 times
    });

    try {
      const message = await client.messages.create({
        model: 'claude-sonnet-4.5',
        max_tokens: 1024,
        messages: [{ role: 'user', content: 'Hello!' }]
      });
      console.log(message.content);
    } catch (error) {
      console.error('API Error:', error);
    }
    ```
  </Tab>
</Tabs>

## Complete Example

Here's a complete application example:

<Tabs>
  <Tab title="Python">
    ```python theme={"dark"}
    #!/usr/bin/env python3
    import os
    from anthropic import Anthropic

    def main():
        # Initialize client
        client = Anthropic(
            base_url="https://api.edgee.ai",
            api_key=os.environ.get("EDGEE_API_KEY"),
            default_headers={
                "x-edgee-tags": "production,chat-app"
            }
        )

        # Chat loop
        conversation = []
        print("Chat with Claude (type 'quit' to exit)")

        while True:
            user_input = input("\nYou: ")
            if user_input.lower() == 'quit':
                break

            conversation.append({
                "role": "user",
                "content": user_input
            })

            # Stream response
            print("\nClaude: ", end="", flush=True)
            with client.messages.stream(
                model="claude-sonnet-4.5",
                max_tokens=1024,
                messages=conversation
            ) as stream:
                assistant_message = ""
                for text in stream.text_stream:
                    print(text, end="", flush=True)
                    assistant_message += text

            conversation.append({
                "role": "assistant",
                "content": assistant_message
            })

    if __name__ == "__main__":
        main()
    ```
  </Tab>

  <Tab title="TypeScript">
    ```typescript theme={"dark"}
    import Anthropic from '@anthropic-ai/sdk';
    import * as readline from 'readline';

    async function main() {
      // Initialize client
      const client = new Anthropic({
        baseURL: 'https://api.edgee.ai',
        apiKey: process.env.EDGEE_API_KEY,
        defaultHeaders: {
          'x-edgee-tags': 'production,chat-app'
        }
      });

      const rl = readline.createInterface({
        input: process.stdin,
        output: process.stdout
      });

      const conversation: Array<{ role: string; content: string }> = [];

      console.log("Chat with Claude (type 'quit' to exit)");

      const chat = () => {
        rl.question('\nYou: ', async (input) => {
          if (input.toLowerCase() === 'quit') {
            rl.close();
            return;
          }

          conversation.push({
            role: 'user',
            content: input
          });

          process.stdout.write('\nClaude: ');

          const stream = await client.messages.create({
            model: 'claude-sonnet-4.5',
            max_tokens: 1024,
            messages: conversation,
            stream: true,
          });

          let assistantMessage = '';
          for await (const event of stream) {
            if (event.type === 'content_block_delta'
                && event.delta.type === 'text_delta') {
              process.stdout.write(event.delta.text);
              assistantMessage += event.delta.text;
            }
          }

          conversation.push({
            role: 'assistant',
            content: assistantMessage
          });

          chat();
        });
      };

      chat();
    }

    main();
    ```
  </Tab>
</Tabs>