One base URL. 24 AI providers. Zero "rate limit exceeded" dead ends.

Syok AI gives every account a personal, OpenAI-compatible endpoint. Point Cursor, LangChain, LiteLLM, or your agent framework at it once — Syok routes each request across the providers you've connected and moves to the next one the instant the first hits a rate limit or runs out of credits.

Works anywhere you can set an OpenAI-compatible base URL

Coding assistants such as Cursor, Cline, Aider and Continue; frameworks such as LangChain, LlamaIndex, LiteLLM, the Vercel AI SDK, the OpenAI Agents SDK, CrewAI, Pydantic AI and LangGraph; and agent harnesses and orchestrators (ruflo and similar) — anywhere the tool lets you enter a custom base URL and API key, Syok AI slots in as the provider.

# Any OpenAI SDK or compatible tool:
base URL:  https://YOUR-SYOK-URL/v1
API key:   syk_...        (created in the Syok AI app)
model:     syok-auto      (or a specific model your providers serve)

Streaming, tool/function calling, and OpenAI-style image and video endpoints are supported. Each reply tells you who actually answered (X-Syok-Provider) and how many providers were skipped on the way (X-Syok-Fallbacks). Full examples for every framework are in the developer docs.

Why route your agents through Syok AI?

Rate limits are where agent runs die. An agent loop can make dozens of calls in a minute; one 429 and the whole run stalls. Syok tries your providers in order, benches the one that just failed for a few minutes, and re-sends the full conversation to the next — trimmed only when a provider's context window requires it. Your tool just sees a completed request.

Your keys stay yours. Syok AI is bring-your-own-key: your provider keys are AES-256-GCM encrypted with a secret that exists only on your own Cloudflare Worker, in your own Cloudflare account. Syok never pools credits or resells tokens.

Every switch is on the record. The app keeps a Switch Transparency Log — when a provider failed, which one answered instead, and why — plus a monthly tally of the rate-limit moments Syok routed around for you.

Cheap models, one roof. Connect OpenRouter or SiliconFlow and any model they serve is reachable through the same endpoint — including budget MoE models like inclusionai/ling-3.1-flash — next to your Gemini, Groq, Mistral, OpenAI or Claude keys.

Step by step for popular tools

Every guide below needs the same two things: your personal base URL and a developer key (syk_…). The model name is always syok-auto. Not sure where to find them? See "Set up in three steps" further down.

n8n

1. Add an OpenAI Chat Model node and connect it to your AI Agent or chain.
2. Under Credential to connect with, create a new OpenAI credential: API Key = your syk_… key, Base URL = your base URL ending in /v1, and leave Organization ID empty. n8n saves it after asking Syok for its model list.
3. In Model, enter syok-auto (if it is not in the list, switch the field to "By ID").
4. Turn off "Use Responses API" so n8n uses the standard chat endpoint.

Flowise

1. Add a ChatOpenAI node.
2. Under Connect Credential, create an OpenAI credential and paste your syk_… key.
3. Set Model Name to syok-auto.
4. Open Additional Parameters and set BasePath to your base URL ending in /v1.
Field names can differ a little between Flowise versions; you are looking for the setting that replaces the OpenAI web address.

CrewAI

import os
from crewai import LLM

llm = LLM(model="openai/syok-auto", base_url="https://YOUR-SYOK-URL/v1", api_key=os.environ["SYOK_API_KEY"])
# pass it to your agent: Agent(role=..., goal=..., backstory=..., llm=llm)

OpenClaw

Add Syok AI as a custom provider in your OpenClaw config, then choose syok/syok-auto as the model:

{
  models: {
    mode: "merge",
    providers: {
      syok: {
        baseUrl: "https://YOUR-SYOK-URL/v1",
        apiKey: "SYOK_API_KEY",   // the name of an environment variable holding your syk_ key
        api: "openai-completions",
        models: [
          { id: "syok-auto", name: "Syok AI (auto)", reasoning: false, input: ["text"],
            cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
            contextWindow: 128000, maxTokens: 8192 },
        ],
      },
    },
  },
}

Check OpenClaw's own documentation if your version expects the key in a different form.

Goose (and Buzz agents)

Goose is a free, open-source coding agent. It already knows how to talk to an OpenAI-style service, so you only change five settings. Type these in the terminal window where you will start Goose:

export GOOSE_PROVIDER=openai
export GOOSE_MODEL=syok-auto
export OPENAI_API_KEY=syk_...                  # your Syok developer key
export OPENAI_HOST=https://YOUR-SYOK-URL       # your base URL, but WITHOUT the /v1 at the end
export OPENAI_BASE_PATH=v1/chat/completions
goose session

On Windows PowerShell, write each line as $env:GOOSE_PROVIDER="openai" instead of export. Those settings last only for that terminal window.

Buzz agents. Buzz has no model address of its own. Its agent runner (buzz-acp) starts an agent program for you, so Goose reads the settings above from the same terminal. Set them first, make sure BUZZ_ACP_AGENT_COMMAND is goose, then start Buzz as usual.

Codex (OpenAI's coding agent)

Codex talks the newer OpenAI "Responses" format, which Syok AI now understands (/v1/responses). Open (or create) the file ~/.codex/config.toml and add:

model = "syok-auto"
model_provider = "syok"

[model_providers.syok]
name = "Syok AI"
base_url = "https://YOUR-SYOK-URL/v1"
env_key = "SYOK_API_KEY"
wire_api = "responses"

Then, in the terminal where you run Codex, set the key once: export SYOK_API_KEY=syk_... and start codex.

Claude Code

Claude Code talks the Anthropic "Messages" format, which Syok AI also understands (/v1/messages). In the terminal where you run it:

export ANTHROPIC_BASE_URL=https://YOUR-SYOK-URL    # WITHOUT the /v1 at the end
export ANTHROPIC_AUTH_TOKEN=syk_...
claude

Claude Code will show Claude model names, but Syok ignores them and uses the best provider you have connected. Agent tools work best when at least one of your connected models handles tool calls well. Answers arrive when they are complete rather than word by word, so that a provider switch can never garble a reply.

LangChain

Install the OpenAI add-on once (pip install langchain-openai), then point it at Syok AI:

import os
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(model="syok-auto", base_url="https://YOUR-SYOK-URL/v1", api_key=os.environ["SYOK_API_KEY"])
print(llm.invoke("Say hello").content)

Using JavaScript? Install @langchain/openai and write:

import { ChatOpenAI } from "@langchain/openai";

const llm = new ChatOpenAI({ model: "syok-auto", apiKey: process.env.SYOK_API_KEY, configuration: { baseURL: "https://YOUR-SYOK-URL/v1" } });
console.log((await llm.invoke("Say hello")).content);

LlamaIndex

Install pip install llama-index-llms-openai-like. This add-on is made for services that speak the OpenAI format but are not OpenAI:

import os
from llama_index.llms.openai_like import OpenAILike

llm = OpenAILike(model="syok-auto", api_base="https://YOUR-SYOK-URL/v1", api_key=os.environ["SYOK_API_KEY"], is_chat_model=True)
print(llm.complete("Say hello"))

PydanticAI

Install pip install "pydantic-ai-slim[openai]", then give the agent a model that points at Syok AI:

import os
from pydantic_ai import Agent
from pydantic_ai.models.openai import OpenAIChatModel
from pydantic_ai.providers.openai import OpenAIProvider

model = OpenAIChatModel("syok-auto", provider=OpenAIProvider(base_url="https://YOUR-SYOK-URL/v1", api_key=os.environ["SYOK_API_KEY"]))
agent = Agent(model)
print(agent.run_sync("Say hello").output)

Older PydanticAI versions call the model class OpenAIModel instead of OpenAIChatModel.

LiteLLM

In Python, put openai/ in front of the model name so LiteLLM uses the OpenAI format:

import os, litellm

reply = litellm.completion(
    model="openai/syok-auto",
    api_base="https://YOUR-SYOK-URL/v1",
    api_key=os.environ["SYOK_API_KEY"],
    messages=[{"role": "user", "content": "Say hello"}],
)
print(reply.choices[0].message.content)

Running the LiteLLM proxy instead? Add this to its config.yaml:

model_list:
  - model_name: syok
    litellm_params:
      model: openai/syok-auto
      api_base: https://YOUR-SYOK-URL/v1
      api_key: os.environ/SYOK_API_KEY

You choose how Syok picks — and you can see what it saves

One-tap presets. In the app's Key book, choose Free only, Cheapest first, Best quality, Smart or My own order. Or write rules in plain words, such as "when it is code, try OpenRouter first".

Money limits. Give any provider a monthly dollar limit. When Syok's estimate reaches it, that provider is skipped until next month.

See the saving. A monthly "What you saved" card and a small label under answers show the estimated saving. It is an estimate based on answer length and a rough price list, never a bill.

See which provider answered, and what it cost you

Every reply carries plain headers, so your code (or a quick curl -i) can see what happened without opening a dashboard:

X-Syok-Provider: Gemini
X-Syok-Model: gemini-3-pro
X-Syok-Fallbacks: 1                          # how many providers failed before this one answered
X-Syok-Attempts: groq:rate_limited,gemini:success
X-Syok-Tier: free                            # free, budget or premium: how expensive the provider that answered is
RateLimit-Limit: 30
RateLimit-Remaining: 29
RateLimit-Reset: 41                          # seconds until your per-minute allowance refills

If a key goes over its limit you get a normal 429 reply with a Retry-After header (in seconds), so well-behaved tools wait and try again by themselves. A key's daily limit refills at midnight UTC.

Want a hard stop on spending? In Syok AI, open Settings and set the price ceiling: Free only, Budget (free plus cheap providers) or No limit. It applies in every mode, including Smart. If nothing you connected fits under the ceiling, Syok's built-in free AI answers instead of quietly going over it.

One overall monthly limit. In the Key book, the Monthly money limits card has an Everything line. It sets one limit for all your paid providers together. When Syok's estimate reaches it, only providers on a free plan keep answering until next month.

Choose per request. Add a header to a single call to override your saved setting for that call only. Nothing is changed in the app:

X-Syok-Mode: free        # manual, cost, smart, free or best
X-Syok-Ceiling: budget   # free, budget or any

With curl, add -H "X-Syok-Mode: free" to your request. Values Syok does not know are ignored, so your saved setting applies.

How Syok AI differs from routers that sell you tokens

Many hosted routers run on their own provider keys and sell you a monthly token allowance. Check any router's terms for how it handles keys, markup and prompts. Here is how Syok AI works:

Set up in three steps

1. Open the Syok AI app and connect at least one provider key (several providers have free tiers; a few gateways need no account at all).
2. In the app, create a developer key — it starts with syk_ and is shown exactly once.
3. Paste your personal base URL and the key into your tool. Done.

Built so a leaked key can't hurt you

A syk_ key can only chat: it can never read, change or export your provider keys, settings or history. Only a hash of the key is stored, it can't be called from a web page, and every key has an expiry date, a per-minute limit and a daily cap you control — plus instant revoke and a one-click "revoke everything" switch. Details in the docs.

Start free — 14 days, no card Read the developer docs

Syok AI is a routing aggregator for your own API keys and is not affiliated with any AI provider listed. $5/month or $30/year after the trial; the developer API is part of the subscription. Questions: [email protected]