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

# Anthropic

> Integrate Anthropic's Claude models with Portkey's AI Gateway

Portkey provides a robust and secure gateway to integrate various Large Language Models (LLMs) into applications, including [Anthropic's Claude APIs](https://docs.anthropic.com/claude/reference/getting-started-with-the-api).

With Portkey, take advantage of features like fast AI gateway access, observability, prompt management, and more, while securely managing API keys through [Model Catalog](https://docs.portkey.ai/docs/product/model-catalog.md).

> [card] All Models
>
> Full support for all Claude models including Sonnet and Haiku 4-5

> [card] All Endpoints
>
> `/messages`, `count-tokens` and more fully supported

> [card] Multi-Provider Support
>
> Use Claude from Anthropic, Bedrock, and Vertex with native SDK support

## Quick Start

Get Anthropic working in 3 steps:

```python Python icon="python" theme={"system"}
from portkey_ai import Portkey

# 1. Install: pip install portkey-ai
# 2. Add @anthropic provider in model catalog
# 3. Use it:

portkey = Portkey(api_key="PORTKEY_API_KEY")

response = portkey.chat.completions.create(
    model="@anthropic/claude-sonnet-4-5-20250929",
    messages=[{"role": "user", "content": "What is Portkey's AI Gateway?"}],
    max_tokens=250  # Required for Anthropic
)

print(response.choices[0].message.content)
```

```js Javascript icon="square-js" theme={"system"}
import Portkey from 'portkey-ai'

// 1. Install: npm install portkey-ai
// 2. Add @anthropic provider in model catalog
// 3. Use it:

const portkey = new Portkey({
    apiKey: "PORTKEY_API_KEY"
})

const response = await portkey.chat.completions.create({
    model: "@anthropic/claude-sonnet-4-5-20250929",
    messages: [{ role: "user", content: "What is Portkey's AI Gateway?" }],
    max_tokens: 250  // Required for Anthropic
})

console.log(response.choices[0].message.content)
```

```python OpenAI Py icon="python" theme={"system"}
from openai import OpenAI
from portkey_ai import PORTKEY_GATEWAY_URL

# 1. Install: pip install openai portkey-ai
# 2. Add @anthropic provider in model catalog
# 3. Use it:

client = OpenAI(
    api_key="PORTKEY_API_KEY",  # Portkey API key
    base_url=PORTKEY_GATEWAY_URL
)

response = client.chat.completions.create(
    model="@anthropic/claude-sonnet-4-5-20250929",
    messages=[{"role": "user", "content": "What is Portkey's AI Gateway?"}],
    max_tokens=250  # Required for Anthropic
)

print(response.choices[0].message.content)
```

```js OpenAI JS icon="square-js" theme={"system"}
import OpenAI from "openai"
import { PORTKEY_GATEWAY_URL } from "portkey-ai"

// 1. Install: npm install openai portkey-ai
// 2. Add @anthropic provider in model catalog
// 3. Use it:

const client = new OpenAI({
    apiKey: "PORTKEY_API_KEY",  // Portkey API key
    baseURL: PORTKEY_GATEWAY_URL
})

const response = await client.chat.completions.create({
    model: "@anthropic/claude-sonnet-4-5-20250929",
    messages: [{ role: "user", content: "What is Portkey's AI Gateway?" }],
    max_tokens: 250  // Required for Anthropic
})

console.log(response.choices[0].message.content)
```

```sh cURL icon="square-terminal" theme={"system"}
# 1. Add @anthropic provider in model catalog
# 2. Use it:

# /chat/completions endpoint (OpenAI-compatible)
curl https://api.portkey.ai/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "x-portkey-api-key: $PORTKEY_API_KEY" \
  -d '{
    "model": "@anthropic/claude-sonnet-4-5-20250929",
    "messages": [
      { "role": "user", "content": "What is Portkey's AI Gateway?" }
    ],
    "max_tokens": 250
  }'

# /messages endpoint (Anthropic native) - also supported
curl https://api.portkey.ai/v1/messages \
  -H "Content-Type: application/json" \
  -H "x-portkey-api-key: $PORTKEY_API_KEY" \
  -d '{
    "model": "@anthropic/claude-sonnet-4-5-20250929",
    "max_tokens": 250,
    "messages": [
      { "role": "user", "content": "What is Portkey's AI Gateway?" }
    ]
  }'
```

```python Anthropic Py theme={"system"}
import anthropic

# 1. Install: pip install anthropic portkey-ai
# 2. Add @anthropic provider in model catalog
# 3. Use it:

client = anthropic.Anthropic(
    api_key="dummy", # we will use portkey's provider slug
    default_headers={"x-portkey-api-key": "YOUR_PORTKEY_API_KEY"},
    base_url="https://api.portkey.ai"
)

message = client.messages.create(
    model="@anthropic/claude-sonnet-4-5-20250929",
    max_tokens=250,
    messages=[{"role": "user", "content": "What is Portkey's AI Gateway?"}]
)

print(message.content)
```

```typescript Anthropic TS theme={"system"}
import Anthropic from '@anthropic-ai/sdk'

// 1. Install: npm install @anthropic-ai/sdk portkey-ai
// 2. Add @anthropic provider in model catalog
// 3. Use it:

const anthropic = new Anthropic({
    apiKey: "PORTKEY_API_KEY",
    baseURL: "https://api.portkey.ai"
})

const msg = await anthropic.messages.create({
    model: "@anthropic/claude-sonnet-4-5-20250929",
    max_tokens: 250,
    messages: [{ role: "user", content: "What is Portkey's AI Gateway?" }],
})

console.log(msg)
```

> [!NOTE]
>
> **Tip:** You can also set `provider="@anthropic"` in `Portkey()` and use just `model="claude-sonnet-4-5-20250929"` in the request.

* **`max_tokens` is required** - Always specify this parameter
* **System prompts** - Handled differently (see System Prompts section below)
* **Model naming** - Use full model names like `claude-sonnet-4-5-20250929`

## Add Provider in Model Catalog

1. Go to [**Model Catalog → Add Provider**](https://app.portkey.ai/model-catalog/providers)
2. Select **Anthropic**
3. Choose existing credentials or create new by entering your [Anthropic API key](https://console.anthropic.com/settings/keys)
4. Name your provider (e.g., `anthropic-prod`)

To connect without an API key, use [Workload Identity Federation](https://docs.portkey.ai/docs/product/model-catalog/workload-identity-federation.md) with Microsoft Entra ID, Okta, or another OIDC identity provider.

> [card] [Complete Setup Guide →](https://docs.portkey.ai/docs/product/model-catalog.md)
>
> See all setup options, code examples, and detailed instructions

## Basic Usage

### Chat Completions

```js Javascript icon="square-js" theme={"system"}
import Portkey from 'portkey-ai'

const portkey = new Portkey({
    apiKey: "PORTKEY_API_KEY"
})

const response = await portkey.chat.completions.create({
    model: "@anthropic/claude-sonnet-4-5-20250929",
    messages: [
        { role: "system", content: "You are a helpful assistant." },
        { role: "user", content: "What is Portkey's AI Gateway?" }
    ],
    max_tokens: 250  // Required
})

console.log(response.choices[0].message.content)
```

### System Prompts

Anthropic handles system prompts differently than OpenAI. With Portkey, you can use the OpenAI-compatible format:

```python Python icon="python" theme={"system"}
response = portkey.chat.completions.create(
    model="@anthropic/claude-sonnet-4-5-20250929",
    messages=[
        {"role": "system", "content": "You are a snarky assistant."},
        {"role": "user", "content": "How do I boil water?"}
    ],
    max_tokens=250
)
```

```js Javascript icon="square-js" theme={"system"}
const response = await portkey.chat.completions.create({
    model: "@anthropic/claude-sonnet-4-5-20250929",
    messages: [
        { role: "system", content: "You are a snarky assistant." },
        { role: "user", content: "How do I boil water?" }
    ],
    max_tokens: 250
})
```

Portkey automatically formats this for Anthropic's API.

### Streaming

Streaming works the same as OpenAI:

```python Python icon="python" theme={"system"}
response = portkey.chat.completions.create(
    model="@anthropic/claude-sonnet-4-5-20250929",
    messages=[{"role": "user", "content": "Tell me a story"}],
    max_tokens=500,
    stream=True
)

for chunk in response:
    if chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="")
```

```js Javascript icon="square-js" theme={"system"}
const response = await portkey.chat.completions.create({
    model: "@anthropic/claude-sonnet-4-5-20250929",
    messages: [{ role: "user", content: "Tell me a story" }],
    max_tokens: 500,
    stream: true
})

for await (const chunk of response) {
    if (chunk.choices[0].delta.content) {
        process.stdout.write(chunk.choices[0].delta.content)
    }
}
```

### Catch Overloaded Error on Stream

Anthropic's API can return an `overloaded_error` inside a streaming response with HTTP status 200. The error appears as an SSE event:

```text theme={"system"}
event: error
data: {"type": "error", "error": {"type": "overloaded_error", "message": "Overloaded"}}
```

By default, the gateway treats this as a successful (status 200) response and streams the error directly to the client, which means retry, fallback, and circuit breaker strategies do not activate (they rely on HTTP status codes).

When **Catch Overloaded Error on Stream** is enabled on an Anthropic integration, the gateway intercepts these errors before they reach the client and converts them into HTTP `529` responses, allowing your retry and fallback strategies to trigger automatically.

> [!NOTE]
>
> This feature is only available for the Anthropic provider. Other providers (e.g., Bedrock) handle overload errors at the HTTP level, where existing retry/fallback already applies. It also only applies to **streaming** requests — non-streaming Anthropic requests already return HTTP 529 directly.

#### How it works

When enabled on an integration, the gateway:

1. Reads the first chunk of the Anthropic streaming response before committing it to the client
2. Skips any keepalive ping events
3. If the first meaningful event is an `overloaded_error`, returns an HTTP `529` response instead of the stream
4. If the first event is normal content, continues streaming as usual with no data loss

If no retry strategy is present and an `overloaded_error` is found, the request fails as a normal request with error `529`.

The `529` response integrates with the gateway's existing error handling and supports all existing config combinations:

* **Retry**: Triggers automatically when retry is configured
* **Fallback**: Moves to the next target in a fallback strategy
* **Circuit breaker**: Counts as a failure for circuit breaker thresholds

> [!NOTE]
>
> Performance: There is zero overhead when the setting is disabled. When enabled, only the first event is inspected before the stream is committed.

#### How to enable

**1. Enable the flag on your Anthropic integration**

Go to **Model Catalog → Integrations → Anthropic** and enable the **Catch Overloaded Error on Stream** flag, then create or update the integration.

**2. Add 529 to your retry status codes**

In your [config](https://docs.portkey.ai/docs/product/ai-gateway/configs.md), add `529` to the retry `on_status_codes` (or fallback `on_status_codes`). This supports all existing config combinations.

**3. Attach the config to your API key**

Attach the updated config to your API key so the new behavior applies to all routed requests.

Once enabled, all Anthropic streaming requests routed through the gateway are checked for overloaded errors.

#### Example: Fallback on overload

With a fallback config using two Anthropic integrations (both with **Catch Overloaded Error on Stream** enabled), if the primary returns an overloaded error during streaming, the gateway automatically retries with the backup:

```json theme={"system"}
{
  "strategy": { "mode": "fallback" },
  "targets": [
    { "provider": "anthropic", "virtual_key": "anthropic-primary" },
    { "provider": "anthropic", "virtual_key": "anthropic-backup" }
  ]
}
```

#### Error response

When an overloaded error is detected, the client receives:

```http theme={"system"}
HTTP/1.1 529
{
  "error": {
    "message": "Overloaded",
    "type": "overloaded_error",
    "param": null,
    "code": null
  }
}
```

## Advanced Features

### Vision (Multimodal)

Portkey supports Anthropic's vision models including `claude-sonnet-4-5-20250929`, `claude-3-5-sonnet`, `claude-3-haiku`, `claude-3-opus`, and `claude-3.7-sonnet`. Use the same format as OpenAI:

> [!NOTE]
>
> Anthropic **only accepts base64-encoded images** and does not support image URLs. Use the same base64 format to send images to both Anthropic and OpenAI models.

```python Python icon="python" theme={"system"}
import base64
import httpx
from portkey_ai import Portkey

portkey = Portkey(api_key="PORTKEY_API_KEY")

# Fetch and encode the image
image_url = "https://upload.wikimedia.org/wikipedia/commons/a/a7/Camponotus_flavomarginatus_ant.jpg"
image_data = base64.b64encode(httpx.get(image_url).content).decode("utf-8")

response = portkey.chat.completions.create(
    model="@anthropic/claude-sonnet-4-5-20250929",
    messages=[{
        "role": "user",
        "content": [
            {"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{image_data}"}},
            {"type": "text", "text": "What's in this image?"}
        ]
    }],
    max_tokens=300
)

print(response.choices[0].message.content)
```

```js Javascript icon="square-js" theme={"system"}
import Portkey from 'portkey-ai'
import axios from 'axios'

const portkey = new Portkey({
    apiKey: "PORTKEY_API_KEY"
})

// Fetch and encode the image
const imageUrl = "https://upload.wikimedia.org/wikipedia/commons/a/a7/Camponotus_flavomarginatus_ant.jpg"
const imageResponse = await axios.get(imageUrl, { responseType: 'arraybuffer' })
const imageBase64 = Buffer.from(imageResponse.data).toString('base64')

const response = await portkey.chat.completions.create({
    model: "@anthropic/claude-sonnet-4-5-20250929",
    messages: [{
        role: "user",
        content: [
            { type: "image_url", image_url: { url: `data:image/jpeg;base64,${imageBase64}` } },
            { type: "text", text: "What's in this image?" }
        ]
    }],
    max_tokens: 300
})

console.log(response.choices[0].message.content)
```

> [!NOTE]
>
> To prompt with PDFs, update the `url` field to: `data:application/pdf;base64,BASE64_PDF_DATA`

### PDF Support

Anthropic Claude processes PDFs to extract text, analyze charts, and understand visual content. PDF support is available on:

* Claude 3.7 Sonnet (`claude-3-7-sonnet-20250219`)
* Claude 3.5 Sonnet (`claude-3-5-sonnet-20241022`, `claude-3-5-sonnet-20240620`)
* Claude Sonnet 4-5 (`claude-sonnet-4-5-20250929`)
* Claude 3.5 Haiku (`claude-3-5-haiku-20241022`)

**Limitations:**

* Maximum request size: 32MB
* Maximum pages per request: 100
* Format: Standard PDF (no passwords/encryption)

```python Python icon="python" theme={"system"}
from portkey_ai import Portkey
import base64
import httpx

portkey = Portkey(api_key="PORTKEY_API_KEY")

# Fetch and encode the PDF
pdf_url = "https://assets.anthropic.com/m/1cd9d098ac3e6467/original/Claude-3-Model-Card-October-Addendum.pdf"
pdf_data = base64.standard_b64encode(httpx.get(pdf_url).content).decode("utf-8")

response = portkey.chat.completions.create(
    model="@anthropic/claude-sonnet-4-5-20250929",
    max_tokens=1024,
    messages=[
        {"role": "system", "content": "You are a helpful document analysis assistant."},
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "What are the key findings in this document?"},
                {"type": "file", "file": {"mime_type": "application/pdf", "file_data": pdf_data}}
            ]
        }
    ]
)

print(response.choices[0].message.content)
```

```js Javascript icon="square-js" theme={"system"}
import Portkey from 'portkey-ai'
import axios from 'axios'

const portkey = new Portkey({
    apiKey: "PORTKEY_API_KEY"
})

// Fetch and encode the PDF
const pdfUrl = "https://assets.anthropic.com/m/1cd9d098ac3e6467/original/Claude-3-Model-Card-October-Addendum.pdf"
const pdfResponse = await axios.get(pdfUrl, { responseType: 'arraybuffer' })
const pdfBase64 = Buffer.from(pdfResponse.data).toString('base64')
const pdfData = `data:application/pdf;base64,${pdfBase64}`

const response = await portkey.chat.completions.create({
    model: "@anthropic/claude-sonnet-4-5-20250929",
    max_tokens: 1024,
    messages: [
        { role: "system", content: "You are a helpful document analysis assistant." },
        {
            role: "user",
            content: [
                { type: "text", text: "What are the key findings in this document?" },
                { type: "file", file: { mime_type: "application/pdf", file_data: pdfData } }
            ]
        }
    ]
})

console.log(response.choices[0].message.content)
```

### Extended Thinking (Reasoning Models)

Models like `claude-3-7-sonnet-latest` support [extended thinking](https://docs.anthropic.com/en/docs/build-with-claude/extended-thinking#streaming-extended-thinking). Get the model's reasoning as it processes the request.

> [!NOTE]
>
> The assistant's thinking response is returned in the `response_chunk.choices[0].delta.content_blocks` array, not the `response.choices[0].message.content` string.

Set `strict_open_ai_compliance=False` to use this feature:

```python Python icon="python" theme={"system"}
from portkey_ai import Portkey

portkey = Portkey(
    api_key="PORTKEY_API_KEY",
    strict_open_ai_compliance=False
)

response = portkey.chat.completions.create(
    model="@anthropic/claude-3-7-sonnet-latest",
    max_tokens=3000,
    thinking={"type": "enabled", "budget_tokens": 2030},
    stream=False,
    messages=[{
        "role": "user",
        "content": [{
            "type": "text",
            "text": "when does the flight from new york to bengaluru land tomorrow, what time, what is its flight number, and what is its baggage belt?"
        }]
    }]
)

print(response)
```

```js Javascript icon="square-js" theme={"system"}
import Portkey from 'portkey-ai'

const portkey = new Portkey({
    apiKey: "PORTKEY_API_KEY",
    strictOpenAiCompliance: false
})

const response = await portkey.chat.completions.create({
    model: "@anthropic/claude-3-7-sonnet-latest",
    max_tokens: 3000,
    thinking: { type: "enabled", budget_tokens: 2030 },
    stream: false,
    messages: [{
        role: "user",
        content: [{
            type: "text",
            text: "when does the flight from new york to bengaluru land tomorrow, what time, what is its flight number, and what is its baggage belt?"
        }]
    }]
})

console.log(response)
```

### Using /messages Route

Portkey supports Anthropic's `/messages` endpoint, allowing you to use either Anthropic's native SDK or Portkey's SDK with full gateway features.

#### Using Anthropic's Native SDK

```python Anthropic Py theme={"system"}
import anthropic

client = anthropic.Anthropic(
    api_key="dummy", # we will use portkey's provider slug
    default_headers={"x-portkey-api-key": "YOUR_PORTKEY_API_KEY"},
    base_url="https://api.portkey.ai"
)

message = client.messages.create(
    model="@your-provider-slug/claude-sonnet-4-5-20250929",
    max_tokens=250,
    messages=[{"role": "user", "content": "Hello, Claude"}]
)

print(message.content)
```

```typescript Anthropic TS theme={"system"}
import Anthropic from '@anthropic-ai/sdk'

const anthropic = new Anthropic({
    apiKey: "YOUR_PORTKEY_API_KEY",
    baseURL: "https://api.portkey.ai"
})

const msg = await anthropic.messages.create({
    model: "@your-provider-slug/claude-sonnet-4-5-20250929",
    max_tokens: 1024,
    messages: [{ role: "user", content: "Hello, Claude" }]
})

console.log(msg)
```

#### Using Portkey's SDK

```sh cURL icon="square-terminal" theme={"system"}
curl --location 'https://api.portkey.ai/v1/messages' \
--header 'x-portkey-provider: anthropic' \
--header 'Content-Type: application/json' \
--header 'x-portkey-api-key: YOUR_PORTKEY_API_KEY' \
--data-raw '{
    "model": "@your-provider-slug/claude-sonnet-4-5-20250929",
    "max_tokens": 1024,
    "stream": true,
    "messages": [
        {
            "role": "user",
            "content": "What is the weather like in Chennai?"
        }
    ]
}'
```

> [!NOTE]
>
> You can use all Portkey features (like caching, observability, configs) with this route. Just add the `x-portkey-config`, `x-portkey-provider`, `x-portkey-...` headers.

### Prompt Caching

Portkey works with Anthropic's prompt caching feature to save time and money. Refer to this guide:

> [card] [Prompt Caching](https://docs.portkey.ai/docs/integrations/llms/anthropic/prompt-caching.md)
>
> Learn how to enable prompt caching for Anthropic requests

### Structured Outputs

Ensure that the model always follows your supplied JSON schema with Portkey's structured outputs support.

> [card] [Structured Outputs](https://docs.portkey.ai/docs/integrations/llms/anthropic/structured-outputs.md)
>
> Learn how to use Pydantic, Zod, or JSON schema for structured data from Anthropic

### Web Search

Anthropic Claude models support web search as a tool, allowing the model to search the web for up-to-date information.

```python Python icon="python" theme={"system"}
from portkey_ai import Portkey

portkey = Portkey(
    api_key="PORTKEY_API_KEY",
    strict_open_ai_compliance=False
)

response = portkey.chat.completions.create(
    model="@anthropic/claude-haiku-4-5-20250929",
    max_tokens=1024,
    messages=[{"role": "user", "content": "What is the latest news on Poland?"}],
    tools=[{
        "type": "web_search",
        "web_search": {
            "name": "web_search_20250305",
            "max_uses": 2
        }
    }]
)

print(response.choices[0].message.content)
```

```js Javascript icon="square-js" theme={"system"}
import Portkey from 'portkey-ai'

const portkey = new Portkey({
    apiKey: "PORTKEY_API_KEY",
    strictOpenAiCompliance: false
})

const response = await portkey.chat.completions.create({
    model: "@anthropic/claude-haiku-4-5-20250929",
    max_tokens: 1024,
    messages: [{ role: "user", content: "What is the latest news on Poland?" }],
    tools: [{
        type: "web_search",
        web_search: {
            name: "web_search_20250305",
            max_uses: 2
        }
    }]
})

console.log(response.choices[0].message.content)
```

```sh cURL icon="square-terminal" theme={"system"}
curl POST 'https://api.portkey.ai/v1/chat/completions' \
  --header 'x-portkey-provider: @my-anthropic' \
  --header 'Content-Type: application/json' \
  --header 'x-portkey-api-key: $PORTKEY_API_KEY' \
  --header 'x-portkey-strict-open-ai-compliance: false' \
  --data '{
    "model": "claude-haiku-4-5",
    "max_tokens": 1024,
    "messages": [
        {
            "role": "user",
            "content": "What is the latest news on Poland?"
        }
    ],
    "tools": [
        {
            "type": "web_search",
            "web_search": {
                "name": "web_search_20250305",
                "max_uses": 2
            }
        }
    ]
}'
```

> [!NOTE]
>
> Set `strict_open_ai_compliance` to `false` (or use the header `x-portkey-strict-open-ai-compliance: false`) to receive citations in the response.

### Files API

Portkey supports Anthropic's [Files API](https://docs.anthropic.com/en/docs/build-with-claude/files) (beta), enabling you to upload, list, retrieve, and delete files through the gateway. Uploaded files can be referenced in chat completions using `file_id` instead of re-uploading content each request.

> [card] [Files API](https://docs.portkey.ai/docs/integrations/llms/anthropic/files.md)
>
> Upload, list, retrieve, and delete files — then use them in chat completions

### Service Tier

When routing Chat Completions requests to Anthropic, Portkey automatically translates OpenAI's `service_tier` parameter to Anthropic's native `speed` parameter:

| `service_tier` | Anthropic `speed` |
| - | - |
| `auto` | `fast` |
| `standard_only` | `standard` |
| `default` | `standard` |
| `fast` | `fast` |
| `standard` | `standard` |
| unknown value | omitted |

```python Python icon="python" theme={"system"}
from portkey_ai import Portkey

portkey = Portkey(
    api_key="PORTKEY_API_KEY",
    provider="@anthropic"
)

response = portkey.chat.completions.create(
    model="claude-sonnet-4-5",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Hello!"}],
    service_tier="auto"  # maps to speed: "fast" on Anthropic
)
```

```js JavaScript icon="square-js" theme={"system"}
import Portkey from 'portkey-ai'

const portkey = new Portkey({
    apiKey: "PORTKEY_API_KEY",
    provider: "@anthropic"
})

const response = await portkey.chat.completions.create({
    model: "claude-sonnet-4-5",
    max_tokens: 1024,
    messages: [{ role: "user", content: "Hello!" }],
    service_tier: "auto"  // maps to speed: "fast" on Anthropic
})
```

```sh cURL icon="square-terminal" theme={"system"}
curl -X POST https://api.portkey.ai/v1/chat/completions \
  -H "x-portkey-api-key: $PORTKEY_API_KEY" \
  -H "x-portkey-provider: @anthropic" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-sonnet-4-5",
    "max_tokens": 1024,
    "messages": [{"role": "user", "content": "Hello!"}],
    "service_tier": "auto"
  }'
```

### Beta Features

Portkey supports Anthropic's beta features through headers. Pass the beta feature name as the value:

```python Python icon="python" theme={"system"}
from portkey_ai import Portkey

client = Portkey(
    api_key="PORTKEY_API_KEY",
    provider="@anthropic",
    anthropic_beta="token-efficient-tools-2025-02-19",
    strict_open_ai_compliance=False
)
```

```js Javascript icon="square-js" theme={"system"}
import Portkey from 'portkey-ai'

const portkey = new Portkey({
    apiKey: "PORTKEY_API_KEY",
    provider: "@anthropic",
    anthropicBeta: "token-efficient-tools-2025-02-19",
    strictOpenAiCompliance: false
})
```

```sh cURL icon="square-terminal" theme={"system"}
x-portkey-anthropic-beta: "token-efficient-tools-2025-02-19"
```

## Managing Anthropic Prompts

Manage all prompt templates to Anthropic in the [Prompt Library](https://docs.portkey.ai/docs/product/prompt-library.md). All current Anthropic models are supported, and you can easily test different prompts.

Use the `portkey.prompts.completions.create` interface to use the prompt in an application.

## Next Steps

> [card] [Add Metadata](https://docs.portkey.ai/docs/product/observability/metadata.md)
>
> Add metadata to your Anthropic requests

> [card] [Gateway Configs](https://docs.portkey.ai/docs/product/ai-gateway/configs.md)
>
> Add gateway configs to your Anthropic requests

> [card] [Tracing](https://docs.portkey.ai/docs/product/observability/traces.md)
>
> Trace your Anthropic requests

> [card] [Fallbacks](https://docs.portkey.ai/docs/product/ai-gateway/fallbacks.md)
>
> Setup fallback from OpenAI to Anthropic

For complete SDK documentation:

> [card] [SDK Reference](https://docs.portkey.ai/docs/api-reference/sdk/list.md)
>
> Complete Portkey SDK documentation

***

> [card] [Portkey is now PRISMA AIRS AI Gateway. See it in action.](https://www.paloaltonetworks.in/ai-security/ai-gateway?utm_source=portkey\&utm_medium=referral\&utm_campaign=prisma_airs\&utm_content=docs_nav#contact)
>
> Contact Us


## Related topics

- [Anthropic Computer Use](https://docs.portkey.ai/docs/integrations/libraries/anthropic-computer-use.md)
- [Claude Code with Anthropic](https://docs.portkey.ai/docs/integrations/libraries/claude-code-anthropic.md)
- [Comparing DeepSeek Models Against OpenAI, Anthropic & More Using Portkey](https://docs.portkey.ai/docs/guides/use-cases/deepseek-r1.md)
- [HoneyHive](https://docs.portkey.ai/docs/integrations/tracing-providers/honeyhive.md)
- [Amazon Bedrock Mantle](https://docs.portkey.ai/docs/integrations/llms/bedrock-mantle.md)


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.