Anthropic base URL in Python — working examples

By the aitokensai editors · Verified 2026-11-01 Sources: Anthropic docs

Pointing the Anthropic Python SDK at a custom endpoint is one constructor argument. This page shows the four patterns you actually need: sync, streaming, async, and raw HTTP.

curl https://aicomp.ai/v1/models \
  -H "Authorization: Bearer sk-your-gateway-key"

Install

pip install anthropic

The basic pattern

from anthropic import Anthropic

client = Anthropic(
    base_url="https://aicomp.ai", # no /v1 here: the SDK appends /v1/messages itself
    api_key="sk-your-gateway-key", # not an Anthropic-issued key
)

resp = client.messages.create(
    model="claude-sonnet-5",
    max_tokens=256,                # required on this API
    messages=[{"role": "user", "content": "Summarise this in one sentence: {text}"}],
)
print(resp.content[0].text)

Two things to note. max_tokens is required, omit it and the request fails validation. And the text lives in content[0].text, not in a choices array.

Streaming

with client.messages.stream(
    model="claude-sonnet-5",
    max_tokens=512,
    messages=[{"role": "user", "content": "Write a haiku about deployment."}],
) as stream:
    for chunk in stream.text_stream:
        print(chunk, end="", flush=True)

Streaming fails loudly if the endpoint does not support SSE, so it is a good compatibility check before you migrate real traffic.

Async

import asyncio
from anthropic import AsyncAnthropic

client = AsyncAnthropic(base_url="https://aicomp.ai", api_key="sk-your-gateway-key")

async def main():
    resp = await client.messages.create(
        model="claude-sonnet-5",
        max_tokens=256,
        messages=[{"role": "user", "content": "say OK"}],
    )
    print(resp.content[0].text)

asyncio.run(main())

Raw HTTP, no SDK

import requests

r = requests.post(
    "https://aicomp.ai/v1/messages",
    headers={
        "x-api-key": "sk-your-gateway-key",
        "anthropic-version": "2023-06-01",
        "content-type": "application/json",
    },
    json={
        "model": "claude-sonnet-5",
        "max_tokens": 256,
        "messages": [{"role": "user", "content": "say OK"}],
    },
    timeout=60,
)
print(r.status_code, r.json())

Note the headers: this API authenticates with x-api-key, not Authorization: Bearer, and it expects an anthropic-version header. Getting these wrong is the most common 401 when moving from an OpenAI-shaped integration.

Reading usage

print(resp.usage.input_tokens, resp.usage.output_tokens)

Log these per request. Output tokens cost several times more than input, so a model that talks more than it needs is measurably more expensive even at the same rate.

Rates for the models above

Rates checked 2026-11-01. Gateway rates move with upstream promotions (verify the current number in your dashboard before committing to a budget).

Troubleshooting

Where the abstraction leaks

How to confirm the change actually took effect

"I set it and nothing happened" is the most common failure here, and it is almost never the endpoint. It is usually the client: a desktop app that reads its own settings file rather than your shell environment, a process started before you exported the variable, or an SDK client instance built once at import time and reused after the config changed. Verify before you debug anything else.

Layer 1, is the endpoint reachable, and does your key work?

curl -s https://aicomp.ai/v1/models \
  -H "Authorization: Bearer $KEY" | head -c 400

A JSON list of model IDs means both are true. An Invalid token body means the endpoint answered but rejected the credential The URL is right, the key is not. An HTML page means something between you and the endpoint (a corporate proxy, a captive portal) answered instead, and no amount of config change will fix it from inside your app.

Layer 2 — who actually answered?

from openai import OpenAI
client = OpenAI(base_url="https://aicomp.ai/v1", api_key=KEY)

r = client.chat.completions.create(
    model="gpt-5.6-luna",
    messages=[{"role": "user", "content": "Reply with the single word: ok"}],
    max_tokens=8,
)
print(r.model)          # 回显的 model 是谁 —— 这是端点身份的唯一硬证据
print(r.usage)          # prompt_tokens / completion_tokens

The model field echoed back is the only hard evidence of identity. A request that silently fell through to a default provider still returns HTTP 200 and still returns sensible text, which is exactly why this layer exists. If the echoed model is not the one you asked for, you are talking to someone else.

Layer 3 — did it land in the usage log?

Reachability is not billing. Open the provider's usage view and look for the model ID you just called, on today's date. If the call succeeded but does not appear, you either hit a cached response or you are still on the old path. This layer is also the one that catches the case where two environments share a key and you are reading the wrong one.

Three ways this check lies to you

• A 200 that is not from the API. Proxies and error pages return 200 with HTML. Check that the body parses as JSON before you trust the status code.
• A stale process. Long-running servers and editors capture configuration at startup. Restart the process, not just the shell.
• A client built before the change. SDK clients snapshot base_url at construction. If yours is a module-level singleton, the new value never reaches it.

FAQ

Related

• The same for the OpenAI SDK
• The same thing in Node.js
• The same endpoint from LangChain
• Migrate from OpenAI to Claude
• Use Claude Code with a custom endpoint
• Claude Sonnet 5 pricing

Get API access