An OpenAI mock API with a scripted model: the same request, the same answer

Connect

The quickest way: set OPENAI_BASE_URL=https://api.sondahub.com/v1 and OPENAI_API_KEY=sk-sondahub, and code that uses the official SDK talks to the sandbox unchanged. That is enough for anything stateless — chat completions, streams, tool calls, embeddings.

For state — stored responses, previous_response_id, background responses, 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 (openai)

from openai import OpenAI, DefaultHttpxClient

# carry the sandbox session (stored responses, 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 = OpenAI(
    base_url='https://api.sondahub.com/v1',
    api_key='sk-sondahub',
    http_client=DefaultHttpxClient(event_hooks={'request': [put], 'response': [keep]}),
)

first = client.responses.create(model='gpt-5.5', input='Say this is a test')
print(first.output_text)                       # This is a test.
second = client.responses.create(model='gpt-5.5', input='And again?', previous_response_id=first.id)

Node (openai)

import OpenAI from 'openai'

// carry the sandbox session (stored responses, the prompt cache) from each answer to the next request
let session = null
const client = new OpenAI({
  baseURL: 'https://api.sondahub.com/v1',
  apiKey: 'sk-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 = await client.chat.completions.create({ model: 'gpt-4o', stream: true, messages: [{ role: 'user', content: '[[tokens:200]]' }] })
for await (const chunk of stream) process.stdout.write(chunk.choices[0]?.delta?.content ?? '')

Import it. In Sonda: Import → From a URL, paste the OpenAPI address. Every operation comes with example bodies — a tool call, structured output, a stream, an error on purpose — so each works as it is. Set the auth to Bearer sk-sondahub.

Try it here

curl https://api.sondahub.com/v1/chat/completions \
  -H "Authorization: Bearer sk-sondahub" \
  -H "Content-Type: application/json" \
  -d '{
  "model": "gpt-5.5",
  "messages": [
    {"role": "developer", "content": "You are a helpful assistant."},
    {"role": "user", "content": "Say this is a test"}
  ]
}'

curl -N https://api.sondahub.com/v1/chat/completions \
  -H "Authorization: Bearer sk-sondahub" \
  -H "Content-Type: application/json" \
  -d '{
  "model": "gpt-4o",
  "stream": true,
  "stream_options": {"include_usage": true},
  "messages": [{"role": "user", "content": "[[tokens:60]] Tell me a story."}]
}'

curl https://api.sondahub.com/v1/chat/completions \
  -H "Authorization: Bearer sk-sondahub" \
  -H "Content-Type: application/json" \
  -d '{
  "model": "gpt-5.5",
  "messages": [{"role": "user", "content": "What'\''s the weather in Paris?"}],
  "tools": [
    {
      "type": "function",
      "function": {
        "name": "get_weather",
        "description": "The weather in a city",
        "parameters": {
          "type": "object",
          "properties": {
            "location": {"type": "string"},
            "unit": {"type": "string", "enum": ["celsius", "fahrenheit"]}
          },
          "required": ["location", "unit"],
          "additionalProperties": false
        },
        "strict": true
      }
    }
  ]
}'

curl https://api.sondahub.com/v1/chat/completions \
  -H "Authorization: Bearer sk-sondahub" \
  -H "Content-Type: application/json" \
  -d '{
  "model": "o4-mini",
  "max_completion_tokens": 200,
  "reasoning_effort": "high",
  "messages": [{"role": "user", "content": "What is (17 * 23) + 4?"}]
}'

curl https://api.sondahub.com/v1/responses \
  -H "Authorization: Bearer sk-sondahub" \
  -H "Content-Type: application/json" \
  -d '{
  "model": "gpt-5.5",
  "input": "Extract the event: Ada and Grace meet on Friday in London.",
  "text": {
    "format": {
      "type": "json_schema",
      "name": "event",
      "strict": true,
      "schema": {
        "type": "object",
        "properties": {
          "name": {"type": "string"},
          "date": {"type": "string", "format": "date"},
          "location": {"type": "string"},
          "participants": {"type": "array", "items": {"type": "string"}}
        },
        "required": ["name", "date", "location", "participants"],
        "additionalProperties": false
      }
    }
  }
}'

curl https://api.sondahub.com/v1/embeddings \
  -H "Authorization: Bearer sk-sondahub" \
  -H "Content-Type: application/json" \
  -d '{
  "model": "text-embedding-3-small",
  "input": [
    "The food was delicious and the waiter was friendly.",
    "The meal was tasty and the staff were kind."
  ],
  "dimensions": 8
}'

curl https://api.sondahub.com/v1/chat/completions \
  -H "Authorization: Bearer sk-sondahub" \
  -H "Content-Type: application/json" \
  -d '{
  "model": "gpt-5.5",
  "messages": [{"role": "user", "content": "Extract: Ada, 36"}],
  "response_format": {
    "type": "json_schema",
    "json_schema": {
      "name": "person",
      "strict": true,
      "schema": {
        "type": "object",
        "properties": {"name": {"type": "string"}, "age": {"type": "integer"}}
      }
    }
  }
}'

curl https://api.sondahub.com/v1/chat/completions \
  -H "Authorization: Bearer sk-sondahub" \
  -H "Content-Type: application/json" \
  -d '{
  "model": "gpt-5.5",
  "messages": [{"role": "user", "content": "[[error:429]] 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 the model you asked for’s stand-in and how to steer it:

Checked like the real API

Requests are refused where OpenAI refuses them, in its words — {"error": {"message", "type", "param", "code"}} — so the mistakes surface here, not in production:

• Unknown fields (“Unrecognized request argument supplied: foo”), wrong types and out-of-range values (invalid_type, decimal_above_max_value…), more than four stop sequences, stream_options without stream.
• An assistant message with tool_calls not followed by a tool message for each id, or a tool message answering nothing; in the Responses API, a function_call_output with an unknown call_id, a continued response whose calls were never answered, and tools in the chat shape ("function": {…}, where the Responses API wants them flat).
• Strict schemas without additionalProperties: false or with properties missing from required; json_object when no message says “json”.
• Reasoning models: max_tokens instead of max_completion_tokens, a temperature or top_p other than 1, an effort the model doesn’t take; the GPT-5.1-and-later rule that sampling settings only go with reasoning_effort: "none".
• Models: a Responses-only model on chat completions, an embedding model asked to chat, a retired one (the deprecation 404), a limit above the model’s output cap, a prompt over its context window.

Streaming

Chat completions stream as the API streams them: a first chunk with the role, content deltas a token or a few at a time, a chunk with the finish_reason, the usage chunk (empty choices) when stream_options.include_usage is set, and data: [DONE]; tool calls arrive as an id and name, then argument fragments. The Responses API streams typed events with sequence_number — response.created, response.in_progress, response.output_item.added, response.content_part.added, response.output_text.delta, the reasoning-summary and function-call-arguments events, the .done events, response.completed (or response.incomplete) — so the SDK’s stream helpers rebuild the same object a plain request returns. Deltas carry obfuscation padding unless include_obfuscation is false. Everything is decided before the first byte: the stream is paced (a short wait, then a few milliseconds per delta), not computed as it goes.

Models

Any of these answers (and GET /v1/models lists them, with the embedding and moderation models); an alias answers as its dated snapshot, as the real API does. Context window and output limit as the sandbox applies them:

Embeddings: text-embedding-3-small (1,536 dimensions), text-embedding-3-large (3,072) and text-embedding-ada-002 (1,536), dimensions on the v3 models. The vectors come from feature hashing — words, letter trigrams, word pairs — normalised to length 1: the same text always gives the same vector, and sentences that share words land close together, so a small semantic search built on them behaves sensibly. Moderations: omni-moderation-latest by default, all 13 categories with scores, nothing flagged without [[flag]].

What it answers

Answers carry x-request-id, openai-processing-ms, openai-version and the x-ratelimit-* headers (a simulated quota; the hub’s X-Sondahub-RateLimit control makes real 429s). Errors on purpose carry retry-after-ms, 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 · Anthropic 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.