WS/v1/realtime

Connect with Authorization: Bearer llmr_sk_live_... as a request header on the WebSocket handshake (same key you use everywhere else). The connection is gated once, at connect time (scope, RPM/TPM, monthly spend cap, credit balance) — a rejected connection closes immediately with a 4400-range close code and a plain-text reason (4400 unsupported model/provider, 4401 invalid key, 4403 missing scope, 4402 spend cap / no credit, 4429 rate limited, 4502 upstream provider not configured/reachable).

Model & provider selection

?model= picks the model (defaults to gpt-realtime-2 if omitted); ?provider= picks which real inference provider serves it, for the models with more than one — omit it to use that model's default. An unsupported model or an unsupported model/provider pair both close with 4400.

Event protocol

Every frame forwards verbatim in both directions — this is a thin proxy, not a reimplementation of any vendor's protocol, so any client written against the real API works here unmodified with just a base_url/key change. Which protocol that is depends entirely on the chosen model, not on this endpoint. Three distinct shapes:

1. GPT Realtime & Grok Voice — OpenAI's GA Realtime shape

gpt-realtime-2/-2.1/-2.1-mini, the narrower single-purpose gpt-realtime-translate (streaming speech-to-speech translation) and gpt-realtime-whisper (streaming speech-to-text), and grok-voice-think-fast-2.0 — xAI built Grok Voice compatible with this exact vocabulary (live-verified 2026-09-15).

2. Gemini Live — Google's own shape

gemini-3.8-live / gemini-3.8-live-extended-thinking — client speaks FIRST (setup), not server-first like the shape above. Auth to Google is a ?key= query param internally, not a header — irrelevant to you, you always authenticate to this platform the same way regardless of model.

3. GPT Live 1 — its own shape

Client speaks first with session.start — session.model is force-rewritten to "gpt-live-1" server-side regardless of what's sent, since this is the only model billed this way.

delegation.responses fields OpenAI's own docs list: model, instructions, reasoning.effort, text.verbosity, max_output_tokens, parallel_tool_calls — every field forwards untouched, no validation on our side. If model doesn't match this platform's registry, its token usage is silently never billed (voice-minutes still are).

import asyncio, json, websockets

async def main():
    async with websockets.connect(
        "wss://videorouter.sh/v1/realtime?model=gpt-live-1",
        additional_headers={"Authorization": "Bearer llmr_sk_live_..."},
    ) as ws:
        await ws.send(json.dumps({
            "type": "session.start",
            "session": {
                "instructions": "Be concise.",
                "audio": {"format": {"type": "audio/pcm", "rate": 24000}, "output": {"voice": "marin"}},
                "delegation": {"type": "responses", "responses": {"model": "gpt-5.6-luna"}},  # optional
            },
        }))
        print(json.loads(await ws.recv()))  # -> {"type": "session.started", ...}
        await ws.send(json.dumps({"type": "session.close"}))
        print(json.loads(await ws.recv()))  # -> {"type": "session.closed", "usage": {"seconds": ...}, ...}

asyncio.run(main())

Example (Python) — gpt-realtime-2

import asyncio, json, websockets

async def main():
    async with websockets.connect(
        "wss://videorouter.sh/v1/realtime?model=gpt-realtime-2",
        additional_headers={"Authorization": "Bearer llmr_sk_live_..."},
    ) as ws:
        print(json.loads(await ws.recv()))  # -> {"type": "session.created", ...}

        await ws.send(json.dumps({
            "type": "conversation.item.create",
            "item": {"type": "message", "role": "user",
                     "content": [{"type": "input_text", "text": "Say OK."}]},
        }))
        await ws.send(json.dumps({"type": "response.create"}))

        async for message in ws:
            event = json.loads(message)
            if event["type"] == "response.done":
                print(event["response"]["usage"])
                break

asyncio.run(main())

Swap the URL's ?model= and send that model's own event shapes per the tables above to reach any other model on this same endpoint — Grok Voice below is a drop-in swap since it shares the shape above; Gemini Live needs its own client logic since the shape is genuinely different.

Example (Python) — grok-voice-think-fast-2.0

import asyncio, json, websockets

async def main():
    async with websockets.connect(
        "wss://videorouter.sh/v1/realtime?model=grok-voice-think-fast-2.0&provider=xai",
        additional_headers={"Authorization": "Bearer llmr_sk_live_..."},
    ) as ws:
        async for message in ws:
            event = json.loads(message)
            if event["type"] == "session.created":
                await ws.send(json.dumps({
                    "type": "session.update",
                    "session": {"voice": "eve", "instructions": "Be concise.", "turn_detection": None},
                }))
            elif event["type"] == "session.updated":
                await ws.send(json.dumps({
                    "type": "conversation.item.create",
                    "item": {"type": "message", "role": "user",
                             "content": [{"type": "input_text", "text": "Say OK."}]},
                }))
                await ws.send(json.dumps({"type": "response.create"}))
            elif event["type"] == "response.done":
                print(event["response"])  # usage is always {} — billed by session duration, not tokens
                break

asyncio.run(main())

Example (Python) — gemini-3.8-live

import asyncio, json, websockets

async def main():
    async with websockets.connect(
        "wss://videorouter.sh/v1/realtime?model=gemini-3.8-live&provider=google",
        additional_headers={"Authorization": "Bearer llmr_sk_live_..."},
    ) as ws:
        await ws.send(json.dumps({
            "setup": {"model": "models/gemini-3.8-live",
                      "generationConfig": {"responseModalities": ["AUDIO"]}},  # TEXT is rejected
        }))
        sent = False
        async for message in ws:
            event = json.loads(message)
            if "setupComplete" in event and not sent:
                await ws.send(json.dumps({
                    "clientContent": {"turns": [{"role": "user", "parts": [{"text": "Say OK."}]}],
                                      "turnComplete": True},
                }))
                sent = True
            if event.get("serverContent", {}).get("turnComplete"):
                print(event.get("usageMetadata"))  # real token usage, per modality
                break

asyncio.run(main())

Billing

Two shapes, depending on the model — plus the flat 2% platform fee on top either way, same margin as every other endpoint, see /pricing:

• Per token — GPT Realtime and Gemini Live: billed from the real response's usage (three separately-priced modalities — text/audio/image — each with its own input/cached-input/output rate; unaccounted tokens bill at the most expensive known rate rather than being dropped).
• Per session-minute — Grok Voice and GPT Live 1: billed off wall-clock session duration rather than a token count (neither exposes an in-band usage object this platform trusts). GPT Live 1 additionally bills any delegated backend model's own token usage separately — see the GPT Live 1 section above.