From signup to first token in 60 seconds.

Sign in to the console and mint a key. Keys are scoped per workspace; revoke any time.

Wherever you initialize the OpenAI client, change the base_url to ours. Everything else stays. The SDK version, the request shape, the response shape — identical.

  from openai import OpenAI

  client = OpenAI(
      api_key=os.environ["OPENAI_API_KEY"],
    - base_url="https://api.openai.com/v1",
    + base_url="https://api.tkex.ai/v1",
  )

Not just OpenAI — the same gateway is a drop-in for the Anthropic and Gemini SDKs too. Point each SDK at the base below; its own native auth header is accepted (Authorization: Bearer, x-api-key, or x-goog-api-key — all take the same sk- key).

Pick a language. Set TX_API_KEY in your env. Send the request. We route to the model node, you get the same shape OpenAI returns.

curl https://api.tkex.ai/v1/chat/completions \
  -H "Authorization: Bearer $TX_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek/deepseek-v4-pro",
    "messages": [
      {"role": "user", "content": "Say hello in five words."}
    ]
  }'

Models use a vendor/slug id (e.g. deepseek/deepseek-v4-pro). Append @tag to pin a quality variant (e.g. deepseek/deepseek-v4-pro@exacto); omit it for the default. Available slugs are listed on /models.

Every error is a standard HTTP status with a JSON body — { "detail": "..." }. Your existing retry / backoff logic works unchanged.

Set stream=True. Tokens arrive as Server-Sent Events. Same protocol as OpenAI — your existing stream handler works without changes.

stream = client.chat.completions.create(
    model="deepseek/deepseek-v4-pro",
    messages=[{"role": "user", "content": "Count to ten."}],
    stream=True,
)

for event in stream:
    delta = event.choices[0].delta.content
    if delta:
        print(delta, end="", flush=True)

The stream terminates with a data: [DONE] sentinel, exactly like OpenAI. Add stream_options={"include_usage": true} to get a final chunk with token counts.

The gateway proxies more than chat. Same key, same host — just a different path. Rate limit is 600 requests/min per key (60/min for image generations).

Every relay endpoint accepts an optional provider object to steer which upstream serves the request (OpenRouter-compatible). The gateway reads it and strips it — it is never forwarded upstream.

• only / ignore — whitelist / blacklist providers by name (all regions) or name/region.
• order — preferred provider order; earlier entries win, the rest are fallbacks.
• sort — "price" / "latency" / "throughput": deterministic pick along that axis.
• allow_fallbacks — false tries the first provider once, no cross-provider retry.
• quantizations — pin quant variants, e.g. ["fp8"].

{
  "model": "deepseek/deepseek-v4-pro",
  "messages": [{ "role": "user", "content": "Hello" }],
  "provider": {
    "sort": "price",
    "allow_fallbacks": false
  }
}

Every response carries an X-Request-Id header. Send your own X-Request-Id to correlate a call across your services — the same id shows up in your request logs in the console.

For reasoning models, set reasoning_effort ("none" / "low" / "medium" / "high") on a chat request. The model's thinking is returned separately as reasoning_content — choices[0].message.reasoning_content when non-streaming, delta.reasoning_content while streaming.

TokenExchange is a pass-through gateway: every request is relayed to a third-party model provider, and each model you call is governed by that provider's own terms— their acceptable-use policy, data-handling, and availability commitments. We don't modify, waive, or supersede them, so review the applicable provider's terms before sending sensitive data.

See the providers directory for who participates in the routing network, and each model's page for the providers serving it. Your contract with us is the Terms of Service (see §5, Model Providers and Model Terms).