Fix Anthropic Claude API Timeouts: 504 Errors & Solutions (2026)

Both official SDKs default to 10 minutes (600 s) for the total request duration. This covers the time from sending the request until receiving the last byte of the response. There is also a separate connection timeout of about 5 seconds for establishing the TCP connection.

Python — per-request and global timeout

import anthropic
import httpx

# Option A: increase timeout globally on the client
client = anthropic.Anthropic(
    api_key="sk-ant-api03-...",
    timeout=httpx.Timeout(
        connect=10.0,   # TCP handshake
        read=300.0,     # wait for response bytes
        write=30.0,     # sending request body
        pool=10.0,      # waiting for a connection from the pool
    ),
)

# Option B: override timeout for a single request
message = client.messages.create(
    model="claude-3-5-sonnet-20241022",
    max_tokens=4096,
    messages=[{"role": "user", "content": "Summarize this 100-page document..."}],
    timeout=httpx.Timeout(connect=10.0, read=300.0, write=30.0, pool=10.0),
)

print(message.content[0].text)

TypeScript / Node.js — per-request and global timeout

import Anthropic from '@anthropic-ai/sdk';

// Option A: global timeout on the client (milliseconds)
const client = new Anthropic({
  apiKey: process.env.ANTHROPIC_API_KEY,
  timeout: 300_000, // 5 minutes in ms
});

// Option B: per-request timeout override
const message = await client.messages.create(
  {
    model: 'claude-3-5-sonnet-20241022',
    max_tokens: 4096,
    messages: [{ role: 'user', content: 'Summarize this document...' }],
  },
  {
    timeout: 300_000, // 5 minutes — overrides client default
  }
);

console.log(message.content[0].text);

Python — streaming messages

import anthropic

client = anthropic.Anthropic(api_key="sk-ant-api03-...")

# Use stream() context manager — never idles, sidesteps gateway timeouts
with client.messages.stream(
    model="claude-3-5-sonnet-20241022",
    max_tokens=4096,
    messages=[{"role": "user", "content": "Write a detailed analysis..."}],
) as stream:
    for text in stream.text_stream:
        print(text, end="", flush=True)

# Token counts available after stream completes
final = stream.get_final_message()
print(f"\n\nInput tokens:  {final.usage.input_tokens}")
print(f"Output tokens: {final.usage.output_tokens}")

TypeScript — streaming messages

import Anthropic from '@anthropic-ai/sdk';

const client = new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY });

const stream = client.messages.stream({
  model: 'claude-3-5-sonnet-20241022',
  max_tokens: 4096,
  messages: [{ role: 'user', content: 'Write a detailed analysis...' }],
});

// Stream text chunks as they arrive
stream.on('text', (text) => process.stdout.write(text));

// Await the final message for usage stats
const final = await stream.finalMessage();
console.log(`\nTokens used: {final.usage.input_tokens} in / {final.usage.output_tokens} out`);

Go — set timeout on the HTTP client

There is no official Anthropic Go SDK. Pass a custom http.Client with the timeout you need.

package main

import (
    "bytes"
    "context"
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "time"
)

func main() {
    // Use a context with timeout — cleanest approach in Go
    ctx, cancel := context.WithTimeout(context.Background(), 5*time.Minute)
    defer cancel()

    body, _ := json.Marshal(map[string]any{
        "model":      "claude-3-5-sonnet-20241022",
        "max_tokens": 4096,
        "messages": []map[string]string{
            {"role": "user", "content": "Summarize this document..."},
        },
    })

    req, _ := http.NewRequestWithContext(ctx, http.MethodPost,
        "https://api.anthropic.com/v1/messages",
        bytes.NewReader(body),
    )
    req.Header.Set("x-api-key", "sk-ant-api03-...")
    req.Header.Set("anthropic-version", "2023-06-01")
    req.Header.Set("content-type", "application/json")

    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        // context.DeadlineExceeded means your timeout fired
        fmt.Printf("request error: %v\n", err)
        return
    }
    defer resp.Body.Close()

    data, _ := io.ReadAll(resp.Body)
    fmt.Println(string(data))
}

import anthropic
import time
import random

client = anthropic.Anthropic(api_key="sk-ant-api03-...")

def create_with_timeout_retry(max_attempts=3, **kwargs):
    """Retry on timeout and connection errors.
    Only use for idempotent requests."""
    for attempt in range(max_attempts):
        try:
            return client.messages.create(**kwargs)
        except anthropic.APITimeoutError:
            if attempt == max_attempts - 1:
                raise
            wait = (2 ** attempt) + random.random()
            print(f"Timeout on attempt {attempt + 1}, retrying in {wait:.1f}s")
            time.sleep(wait)
        except anthropic.APIConnectionError:
            # Network-level failure — safe to retry
            if attempt == max_attempts - 1:
                raise
            time.sleep(2 ** attempt)

result = create_with_timeout_retry(
    model="claude-3-5-sonnet-20241022",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Hello"}],
)