By Sean Donahoe · Published November 22, 2026.
Open your .env file and count the API keys.
Go on, I'll wait. If you're building anything with an agent in it, there's a key for one model lab and a second for the lab you fall back on when the first one is having a moment. There's one for search. Probably one for a scraper too, because the search key doesn't read pages. Transcription is another account, images are another, and somewhere in there sits the OAuth plumbing you wrote at 1am so the thing could read a Gmail inbox.
Every one of those has its own dashboard, invoice and SDK, plus its own opinion about how an error should look. That's a lot of admin for something that isn't the product.
I built Flux Router to make that pile go away. One key, one bill. It hasn't swallowed the whole pile yet, mind you, so I've split this page into what the key does today and what's still on its way. After that it's the two lines you change, and what it costs.
What the key does today
Same sk-... key, sent as Authorization: Bearer sk-..., on every endpoint and every model. Live today:
- Every major model, with 50+ you can pin by name
- Page reading.
POST /v1/fetchtakes a public URL and hands the page back as clean markdown - Transcription. Upload an audio file, get the text back
- Image generation and editing
Page reading, transcription and images run on a paid key, and so does pinning a model. If you haven't added credit yet, the pricing page is where that happens.
Shipping on the same key: web search, speech, connections to Gmail, Slack, GitHub and more, a second opinion on answers that matter, and memory that follows each user. None of those five is live yet, and I'm not going to write about them as if they were. The abilities page carries a status for each one and it'll say Live when that's true.
I've already written up page reading and transcription on their own, so the request shapes and limits are over there. And if your agent speaks MCP, add https://api.fluxrouter.ai/mcp-tools/ with your Flux key as the bearer token and it gets tools for reading pages and making images (setup is here).
What I like most about all this is also the dullest thing about it, which is that there's nothing new to maintain. Page reading, images and transcription are each one API call on the base URL your chat requests already use. When a new model lands, the only thing that changes on your side is a model name. Nobody opens another account or pastes in another key. (GET /v1/models gives you the live list whenever you want to see what's there.)
What changes when you switch
Two things. The base URL and the key.
If your code speaks the OpenAI shape, it keeps calling POST /v1/chat/completions or POST /v1/responses, only now at https://api.fluxrouter.ai. Anthropic SDK clients set their base URL to https://api.fluxrouter.ai/anthropic and the client adds /v1/messages itself. Both take the same key and reach the same models, with the same routing underneath. Streaming and tool calling work on the standard shapes. Most SDKs and tools carry on unchanged once you repoint them, and I say "most" on purpose, because somebody out there has a client doing something exotic and I'm not going to promise it survives.
Keys come from the dashboard, and this page walks you through making one. Then the whole move, in Python with the OpenAI SDK, is this:
import os
from openai import OpenAI
client = OpenAI(
base_url="https://api.fluxrouter.ai/v1", # change 1
api_key=os.environ["FLUX_API_KEY"], # change 2
)
resp = client.chat.completions.create(
model="flux-auto",
messages=[{"role": "user", "content": "Draft a two-line reply to this customer email: ..."}],
)
print(resp.choices[0].message.content)
Every response also says which model answered and what it cost. That gets a post of its own next, so I'll leave it there.
flux-auto in that example lets the router choose. A classifier picks the lane, then the router picks among models of equivalent quality inside it. If you want one specific model every time, use its flux-pinned-* name (flux-pinned-gemini-4-neon, say, on a paid key) and that's what you get. When to do which was the last post.
Or get your coding agent to do it
Two lines is not a lot of work, but you might have them in forty files. Paste this into whatever agent you code with:
Move this project to FluxRouter. Do not change any logic.
1. OpenAI SDK clients: set the base URL to https://api.fluxrouter.ai/v1.
2. Anthropic SDK clients: set base_url to https://api.fluxrouter.ai/anthropic
(the client adds /v1/messages).
3. Read the key from the FLUX_API_KEY environment variable and pass it as
the client's API key. Raw HTTP calls send it as
"Authorization: Bearer <key>". Never hardcode it, and never send it
to the browser.
4. Use model "flux-auto" unless a call needs one specific model. For those,
call GET /v1/models and use the matching flux-pinned-* id.
5. Make one non-streaming request with "flux-auto" and print the reply
so I can see it works.
List every file you changed.
Read the diff before you merge it. It should be small.
What it costs
Pay as you go is prepaid. You top up credit, calls draw it down, and at $0 the calls stop. Credit never expires. No seats, no minimums.
A pinned model bills at the provider's rate plus 12%. That 12% is the price of having one account instead of several, and I'd rather you read the number here than go hunting for it. flux-auto bills by lane and never above the Standard rate, which starts at $2 per 1M tokens. The rest of the rates are on the pricing page.
Whether that's worth it depends on how many things your agent needs. If you call one model from one lab and you'll never want page reading, transcription or anything else on that list, you can live without Flux and I won't pretend otherwise. The trouble is that agents rarely stay that simple, and the second thing yours needs is another account somewhere.
Two more things to know before you send real traffic.
Flux doesn't train models on your prompts or responses. Your requests do get forwarded to whichever provider serves them, and each of those has its own data terms, so read the ones that matter to you. We keep the operational metadata we need to meter and bill.
And treat the key like the secret it is. Create and revoke keys in the dashboard and keep them server-side. To rotate, issue a new key, move your apps over, then revoke the old one. When one key does everything, that's the one you really don't want sitting in a screenshot.
If you want to try it, start with the script you'd least mind breaking. Change the two lines, run it, and if the answer comes back the way it should, move the next one. The keys you stop needing can come out of .env as you go. Revoke them at the provider as well, because deleting a line from a file doesn't kill a key.
