Put us first, keep your fallback

Tested on 2026-11-12 with openai-python 3.49, openai-node 7.55 and LiteLLM 1.109

Send your open-model traffic to Creekside first and keep the provider you use today as an automatic fallback. If we time out, are busy or cannot answer, the same request goes to your current provider, so trying us carries no reliability risk.

Base URL

https://api.creeksidecompute.ai/v1

API

OpenAI-compatible Chat Completions

Model ids

The same as OpenRouter's: google/gemma-4-31b-it, qwen/qwen3.8-27b, qwen/qwen3.6-35b-a3b, meta/muse-glimmer-30b

Fall back on

A timeout, a lost connection, 402, 404, 408, 429 and every 5xx

Key

In CREEKSIDE_API_KEY. Make one at creeksidecompute.ai/account

Why put us first

• The same API. We speak OpenAI's Chat Completions, so the request body does not change. Only the base URL and the key do.
• The same model ids. Our ids match OpenRouter's, so one request goes to either provider as it is.
• A lower price. Each of these models costs less with us than at the median provider OpenRouter lists for it, read on 2026-11-08. See pricing.
• Your provider stays as the backup. Your code tries us first and moves on by itself when we cannot answer. Nothing changes for your users.

Model ids

Gemma 4 31B, Qwen3.8 27B, Qwen3.6 35B A3B and Muse Glimmer 30B carry the same id on both sides. A prompt longer than the fallback's window cannot fall back, so check the last column for long prompts.

OpenRouter's ids and windows read from its public model list on 2026-11-12. GET /v1/models is authoritative for ours.

Plain code

Two clients, one function. The Creekside client does not retry, so a failure moves to the fallback at once. The fallback keeps its own retries.

import os
import openai
from openai import OpenAI

# First choice: Creekside. No retries here, so a failure moves on at once.
creekside = OpenAI(
    base_url="https://api.creeksidecompute.ai/v1",
    api_key=os.environ["CREEKSIDE_API_KEY"],
    timeout=openai.Timeout(120.0, connect=5.0),
    max_retries=0,
)

# Fallback: the provider you use today, OpenRouter here.
fallback = OpenAI(
    base_url="https://openrouter.ai/api/v1",
    api_key=os.environ["OPENROUTER_API_KEY"],
    timeout=openai.Timeout(120.0, connect=5.0),
    max_retries=2,
)


def chat(**request):
    # Creekside first. On a timeout, a lost connection, 402, 404, 429 or 5xx,
    # the same request goes to the fallback.
    try:
        return creekside.chat.completions.create(**request)
    except openai.APIStatusError as err:
        if err.status_code < 429 and err.status_code not in (402, 404, 408):
            raise  # a bad request fails at both providers
    except openai.APIConnectionError:  # includes timeouts
        pass
    return fallback.chat.completions.create(**request)


response = chat(
    model="qwen/qwen3.8-27b",  # the same id on both
    messages=[{"role": "user", "content": "Say hello."}],
)
print(response.choices[0].message.content)

import OpenAI from "openai";

// First choice: Creekside. No retries here, so a failure moves on at once.
const creekside = new OpenAI({
  baseURL: "https://api.creeksidecompute.ai/v1",
  apiKey: process.env.CREEKSIDE_API_KEY,
  timeout: 120_000,
  maxRetries: 0,
});

// Fallback: the provider you use today, OpenRouter here.
const fallback = new OpenAI({
  baseURL: "https://openrouter.ai/api/v1",
  apiKey: process.env.OPENROUTER_API_KEY,
  timeout: 120_000,
  maxRetries: 2,
});

type Request = OpenAI.Chat.ChatCompletionCreateParamsNonStreaming;

// Creekside first. On a timeout, a lost connection, 402, 404, 429 or 5xx,
// the same request goes to the fallback.
export async function chat(request: Request) {
  try {
    return await creekside.chat.completions.create(request);
  } catch (err) {
    const status = err instanceof OpenAI.APIError ? err.status : undefined;
    const clientError = status !== undefined && status < 429;
    if (clientError && ![402, 404, 408].includes(status)) {
      throw err; // a bad request fails at both providers
    }
    return await fallback.chat.completions.create(request);
  }
}

const response = await chat({
  model: "qwen/qwen3.8-27b", // the same id on both
  messages: [{ role: "user", content: "Say hello." }],
});
console.log(response.choices[0].message.content);

Timeouts. 120 seconds in all suits most chat answers. Raise it for long answers, or stream. The Python client gives up connecting after 5 seconds. Node's fetch gives up after 10 seconds by itself. Under load our API holds a request for room before it answers 429, up to the wait the API reference gives, so a shorter timeout moves to the fallback sooner.

Streaming. In Python, the same function works with stream=True. An error status raises from create() before the first chunk, so the fallback starts before your user sees any text. A stream that breaks after it starts is not sent again.

When the code falls back

LiteLLM

Give LiteLLM two entries for each model, Creekside and OpenRouter, and name the second as the first one's fallback. Your app keeps asking for qwen/qwen3.8-27b.

model_list:
  # First choice: Creekside, through LiteLLM's OpenAI-compatible provider.
  - model_name: qwen/qwen3.8-27b
    litellm_params:
      model: openai/qwen/qwen3.8-27b
      api_base: https://api.creeksidecompute.ai/v1
      api_key: os.environ/CREEKSIDE_API_KEY
      timeout: 120
  # Fallback: the same model on OpenRouter.
  - model_name: qwen/qwen3.8-27b-openrouter
    litellm_params:
      model: openrouter/qwen/qwen3.8-27b
      api_key: os.environ/OPENROUTER_API_KEY
      timeout: 120
  # Repeat the pair for google/gemma-4-31b-it, qwen/qwen3.6-35b-a3b
  # and meta/muse-glimmer-30b: the ids are the same on both sides.

router_settings:
  num_retries: 0
  fallbacks:
    - qwen/qwen3.8-27b: ["qwen/qwen3.8-27b-openrouter"]

Start the proxy with litellm --config config.yaml. In the LiteLLM SDK, pass the same model_list, fallbacks and num_retries to Router(...). LiteLLM sends a failed call to the fallback, rate limits (429) included; we tested a lost connection and a 404. With num_retries: 0, a failure moves to OpenRouter at once.

Cloudflare AI Gateway

Checked against Cloudflare's AI Gateway docs on 2026-11-12

We have not run this setup ourselves; the steps follow Cloudflare's docs. The fallback itself is the tested code above.

1. Add Creekside as a custom provider. In the Cloudflare dashboard, go to Compute & AI, AI Gateway, Custom Providers, and select Add Custom Provider. Set the name to Creekside, the slug to creekside and the base URL to https://api.creeksidecompute.ai, with no /v1. Your gateway then reaches us at custom-creekside.

2. Turn gateway logging off if you want zero retention end to end. Cloudflare logs every request by default, prompt and response included. Turn Logs off in the gateway's settings, or send cf-aig-collect-log: false on each request, as the code below does. cf-aig-collect-log-payload: false keeps a metadata log (tokens, cost, status) without the prompt or the response.

3. Point both clients at the gateway. Creekside through the custom provider, OpenRouter through Cloudflare's built-in OpenRouter provider:

   Python

   import os
   import openai
   from openai import OpenAI
   
   GATEWAY = "https://gateway.ai.cloudflare.com/v1/<account_id>/<gateway_id>"
   # No Cloudflare log of these requests. On an authenticated gateway, add
   # "cf-aig-authorization": "Bearer <gateway token>".
   HEADERS = {"cf-aig-collect-log": "false"}
   
   creekside = OpenAI(
       base_url=f"{GATEWAY}/custom-creekside/v1",
       api_key=os.environ["CREEKSIDE_API_KEY"],
       default_headers=HEADERS,
       timeout=openai.Timeout(120.0, connect=5.0),
       max_retries=0,
   )
   
   fallback = OpenAI(
       base_url=f"{GATEWAY}/openrouter",
       api_key=os.environ["OPENROUTER_API_KEY"],
       default_headers=HEADERS,
       timeout=openai.Timeout(120.0, connect=5.0),
       max_retries=2,
   )

4. Use the chat() function from Plain code as it is. The fallback stays in your code, and both providers' traffic shows in one gateway.

If you use only OpenRouter today

We are not an OpenRouter provider yet, so OpenRouter cannot send your requests to us. Put us in front of it in your own client instead:

• Keep your OpenRouter key and code. Add the Creekside client in front with Plain code or LiteLLM above, and OpenRouter becomes the fallback.
• The model ids are the same, so one request body goes to both.
• Thinking switches carry over: we read OpenRouter's reasoning field, as well as reasoning_effort.
• Send fields that only OpenRouter reads, such as provider and models, on the fallback call alone. In the Python SDK, that is extra_body.

Your data

Zero data retention is the only tier we offer: no conversation archive, content logging, training, sale or licensing. Temporary inference caching is disclosed in our privacy policy. Send x-creekside-retention: none on any request to make sure it is never stored, whatever the key says.

A request that falls back is under your fallback provider's terms, not ours. Through Cloudflare, turn the gateway's logging off as well.

Get a key

1. Sign in at creeksidecompute.ai/account with your email, and make a key.

2. Add credit. Each request is paid from prepaid credit: top up by card, or redeem a promotional code.

3. Want to test first? We add free test credit on request. Write to [email protected].

4. Put the key in an environment variable, beside your current provider's key:

   shell

   export CREEKSIDE_API_KEY=<your key>

Sources, read on 2026-11-12: openai-python, openai-node, LiteLLM fallbacks, Cloudflare's custom providers, OpenRouter provider, logging and dynamic routes, and OpenRouter's model list.