A Claude API mock with a scripted model: the same request, the same answer

Connect

The quickest way: set ANTHROPIC_BASE_URL=https://api.sondahub.com and ANTHROPIC_API_KEY=sk-ant-sondahub, and code that uses the official SDK talks to the sandbox unchanged. That is enough for anything stateless — messages, streams, tool loops, thinking, count_tokens.

For state — batches and the prompt cache — the SDK also has to carry X-Sondahub-Session from each answer to the next request, as below; there is no database, so the token is where those live.

Python (anthropic)

from anthropic import Anthropic, DefaultHttpxClient

# carry the sandbox session (batches, the prompt cache) from each answer to the next request
session = {}
def put(request):
    request.headers.update(session)
def keep(response):
    if 'X-Sondahub-Session' in response.headers:
        session['X-Sondahub-Session'] = response.headers['X-Sondahub-Session']

client = Anthropic(
    base_url='https://api.sondahub.com',
    api_key='sk-ant-sondahub',
    http_client=DefaultHttpxClient(event_hooks={'request': [put], 'response': [keep]}),
)

message = client.messages.create(
    model='claude-opus-5-5',
    max_tokens=1024,
    messages=[{'role': 'user', 'content': 'Say this is a test'}],
)
print(message.content[0].text)                 # This is a test.

TypeScript (@anthropic-ai/sdk)

import Anthropic from '@anthropic-ai/sdk'

// carry the sandbox session (batches, the prompt cache) from each answer to the next request
let session = null
const client = new Anthropic({
  baseURL: 'https://api.sondahub.com',
  apiKey: 'sk-ant-sondahub',
  fetch: async (url, init = {}) => {
    const headers = new Headers(init.headers)
    if (session) headers.set('X-Sondahub-Session', session)
    const res = await fetch(url, { ...init, headers })
    session = res.headers.get('X-Sondahub-Session') ?? session
    return res
  },
})

const stream = client.messages.stream({ model: 'claude-sonnet-5-5', max_tokens: 1024, messages: [{ role: 'user', content: '[[tokens:200]]' }] })
stream.on('text', (text) => process.stdout.write(text))
const final = await stream.finalMessage()

Import it. In Sonda: Import → From a URL, paste the OpenAPI address. Every operation comes with its anthropic-version header and example bodies — a tool call, extended thinking, prompt caching, a batch, an error on purpose. Set the auth: API key sk-ant-sondahub in x-api-key.

Try it here

curl https://api.sondahub.com/v1/messages \
  -H "x-api-key: sk-ant-sondahub" \
  -H "anthropic-version: 2023-06-01" \
  -H "content-type: application/json" \
  -d '{
  "model": "claude-opus-5-5",
  "max_tokens": 1024,
  "messages": [{"role": "user", "content": "Hello, Claude"}]
}'

curl -N https://api.sondahub.com/v1/messages \
  -H "x-api-key: sk-ant-sondahub" \
  -H "anthropic-version: 2023-06-01" \
  -H "content-type: application/json" \
  -d '{
  "model": "claude-sonnet-5-5",
  "max_tokens": 1024,
  "stream": true,
  "messages": [{"role": "user", "content": "[[tokens:60]] Tell me a story."}]
}'

curl https://api.sondahub.com/v1/messages \
  -H "x-api-key: sk-ant-sondahub" \
  -H "anthropic-version: 2023-06-01" \
  -H "content-type: application/json" \
  -d '{
  "model": "claude-opus-5-5",
  "max_tokens": 1024,
  "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"]
      }
    }
  ],
  "messages": [{"role": "user", "content": "What'\''s the weather like in San Francisco?"}]
}'

curl https://api.sondahub.com/v1/messages \
  -H "x-api-key: sk-ant-sondahub" \
  -H "anthropic-version: 2023-06-01" \
  -H "content-type: application/json" \
  -d '{
  "model": "claude-opus-5-5",
  "max_tokens": 16000,
  "thinking": {"type": "enabled", "budget_tokens": 10000},
  "messages": [{"role": "user", "content": "What is (17 * 23) + 4?"}]
}'

DOC=$(printf 'You answer questions about the sondahub handbook. The handbook says: every API is a mock, every write is kept in a session token the client carries, and nothing is stored on the server. %.0s' $(seq 30))
curl https://api.sondahub.com/v1/messages \
  -H "x-api-key: sk-ant-sondahub" \
  -H "anthropic-version: 2023-06-01" \
  -H "content-type: application/json" \
  -d '{
  "model": "claude-sonnet-5-5",
  "max_tokens": 1024,
  "system": [{"type": "text", "text": "'"$DOC"'", "cache_control": {"type": "ephemeral"}}],
  "messages": [{"role": "user", "content": "Where is my data kept?"}]
}'

curl https://api.sondahub.com/v1/messages/count_tokens \
  -H "x-api-key: sk-ant-sondahub" \
  -H "anthropic-version: 2023-06-01" \
  -H "content-type: application/json" \
  -d '{
  "model": "claude-opus-5-5",
  "messages": [{"role": "user", "content": "Hello, world"}]
}'

curl https://api.sondahub.com/v1/messages/batches \
  -H "x-api-key: sk-ant-sondahub" \
  -H "anthropic-version: 2023-06-01" \
  -H "content-type: application/json" \
  -d '{
  "requests": [
    {
      "custom_id": "first",
      "params": {
        "model": "claude-opus-5-5",
        "max_tokens": 1024,
        "messages": [{"role": "user", "content": "Say batch one"}]
      }
    },
    {
      "custom_id": "second",
      "params": {
        "model": "claude-haiku-4-5",
        "max_tokens": 1024,
        "messages": [{"role": "user", "content": "What is 6 * 7?"}]
      }
    }
  ]
}'

curl https://api.sondahub.com/v1/messages \
  -H "x-api-key: sk-ant-sondahub" \
  -H "anthropic-version: 2023-06-01" \
  -H "content-type: application/json" \
  -d '{
  "model": "claude-opus-5-5",
  "max_tokens": 1024,
  "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"]
      }
    }
  ],
  "messages": [
    {"role": "user", "content": "What'\''s the weather in Oslo?"},
    {
      "role": "assistant",
      "content": [
        {
          "type": "tool_use",
          "id": "toolu_01Sx3sondahubExample9QzT",
          "name": "get_weather",
          "input": {"location": "Oslo"}
        }
      ]
    },
    {"role": "user", "content": "Never mind."}
  ]
}'

curl https://api.sondahub.com/v1/messages \
  -H "x-api-key: sk-ant-sondahub" \
  -H "anthropic-version: 2023-06-01" \
  -H "content-type: application/json" \
  -d '{
  "model": "claude-opus-5-5",
  "max_tokens": 1024,
  "messages": [{"role": "user", "content": "[[error:529]] hello"}]
}'

From the shell, keep the token yourself: curl -i shows X-Sondahub-Session; send it back with -H "X-Sondahub-Session: …". How sessions work.

The scripted model

No model runs here. A script answers, and it reads the conversation the way a test wants a model to: the same request always gets the same answer, instantly, for nothing. It still does a few useful things on its own — “Say this is a test” answers This is a test., an arithmetic question gets its answer, a message that names a tool (by a word of its name: “weather” for get_weather) calls it with arguments made from its schema and your words (the city after “in”, the numbers in order), a turn that brings tool results back gets a reply that reports them, and a JSON schema gets an object that fits it, required fields, enums and formats included. Anything else gets a short note saying it is Claude’s stand-in and how to steer it:

With tools and tool_choice: auto a short text block comes before the tool_use (“I’ll use get_weather for this.”), as Claude tends to write one; a forced choice goes straight to the call. With thinking on, a thinking block comes first, its text saying what the script decided and why. A final assistant message is a prefill, and the reply continues it.

Checked like the real API

Requests are refused where the API refuses them, in its words — {"type": "error", "error": {"type", "message"}, "request_id"}, with field paths like messages.1.content.0 — so the mistakes surface here, not in production:

• Missing and unknown fields (“max_tokens: Field required”, “foo: Extra inputs are not permitted”), wrong types, a missing or unknown anthropic-version, max_tokens above the model’s output limit, a prompt over its context window.
• A tool_use not answered by a tool_result in the next message, or a tool_result answering nothing; duplicate tool names; an input_schema that isn’t an object.
• Thinking: budget_tokens under 1,024 or not below max_tokens, a forced tool_choice with thinking on, a temperature other than 1, a changed thinking block, a tool loop without its thinking block.
• Caching: more than four cache_control blocks, a 1-hour breakpoint after a 5-minute one, cache_control on empty text.
• Models: unknown ones and retired ones (Claude 3, Claude 4.0, Mythos Preview) answer 404 not_found_error; an alias answers as its dated id.

Streaming, thinking and caching

A stream is the API’s event sequence: message_start (with input usage), then per block content_block_start, its deltas — text_delta, input_json_delta partial JSON, thinking_delta then one signature_delta — and content_block_stop, a ping after the first block starts, message_delta with the stop reason and final usage, and message_stop. The SDK’s stream helpers rebuild the same Message a plain request returns. Everything is decided before the first byte: the stream is paced, not computed as it goes.

Stop reasons are the API’s: end_turn, max_tokens, stop_sequence (naming the one hit), tool_use and refusal. Thinking spends tokens inside max_tokens — with enabled up to its budget, with adaptive by output_config.effort (none at low) — counted in output_tokens and in output_tokens_details.thinking_tokens.

Message Batches

POST /v1/messages/batches takes up to 50 requests (16 KB in all — the batch lives in your session token; the real API takes 100,000). The batch is in_progress for a few seconds (twenty with [[slow]] in a request), then ended with its request_counts and a results_url; the results are JSONL, one line per custom_id: succeeded with the message (service tier batch), or errored with the error that request would have got on its own. Cancel one in progress and it goes canceling, then ends with its requests canceled; delete it once it has ended. The session keeps the latest five.

Models

GET /v1/models lists these newest first, with limit, after_id and before_id, each with its display name, release date, limits and capabilities:

What it answers

Answers carry request-id and the anthropic-ratelimit-* headers (a simulated quota; the hub’s X-Sondahub-RateLimit control makes real 429s). Errors on purpose carry retry-after, so the SDK’s retries are quick.

Also on sondahub

Fake REST API · Public GraphQL API · gRPC-Web & Connect · WebSocket test server · SSE test server · Public MQTT broker · MCP test server · MCP OAuth test server · Writes that persist · OpenAPI mock server · Webhook tester · Chaos and rate limits · SAML test IdP and SP · SCIM 2.0 test server · OAuth 2.0 test server · Auth test endpoints · HTTP test endpoints · Fake JSON data · JSONPlaceholder alternative · Stripe sandbox · Twilio sandbox · SendGrid sandbox · Authorize.net sandbox · OpenAI sandbox

The mock APIs themselves: fake e-commerce API, fake IoT API, fake banking API, fake social media API, fake helpdesk API, fake flight booking API, fake user directory API. Built as the playground for LockFlare Sonda, the API client that lives on your computer.