Your ChatGPT plan, as an OpenAI-compatible API
Connect your ChatGPT account, get an endpoint, and create keys you can drop into any OpenAI SDK. Every request runs on your own plan — accounts are never pooled, nothing is shared, and this service never sees your password.
Works on free and paid ChatGPT plans. No credit card, no billing.
curl https://api.zap.dscv.me/v1/chat/completions \
-H "Authorization: Bearer sk_live_..." \
-H "Content-Type: application/json" \
-d '{
"model": "gpt-5.5",
"messages": [{ "role": "user", "content": "Hello" }],
"stream": true
}'data: {…,"delta":{"role":"assistant"}}data: {…,"delta":{"content":"Hel"}}data: {…,"delta":{"content":"lo!"}}data: [DONE]Three steps, about two minutes
The only unusual part is step two, and that is OpenAI's constraint rather than ours: it only accepts a localhost redirect from a browser.
Sign in with ChatGPT
One click, and the account is created from your ChatGPT identity — no password to set, nothing to confirm by email.
Connect ChatGPT
One click, via the browser extension that completes OpenAI's localhost redirect. Tokens are encrypted before they are written down.
Create an API key
Point any OpenAI-compatible client at your endpoint and use the key as the bearer token.
Built to be pointed at and forgotten
The API host is a long-lived process, not a serverless function, because that is what streaming and per-key state actually need.
Drop-in for any OpenAI SDK
The surface is /v1/models, /v1/chat/completions, /v1/responses and /v1/images/*. Change the base URL and nothing else.
Streaming that actually streams
Server-sent events pass straight through a long-lived process — no function timeout, no proxy buffering a long run into one delayed blob.
Keys you can revoke
Named keys, hashed at rest, revocable instantly. Every request is attributed to the key that made it, with per-key rate limiting.
One account per person
Your requests run on your own plan. Accounts are never pooled, and there is no shared quota to compete for.
Two things worth being upfront about
Neither is a dealbreaker, but both change what you are trusting this service with, so they should not be a surprise later.
A browser extension is required
OpenAI only redirects to http://localhost:1455/auth/callback, which a hosted site can never receive. The Sign in with ChatGPT extension intercepts that redirect and hands the result back to the dashboard. Without it, you cannot connect an account. That is a real limitation, not a missing feature.
Your refresh token is stored
An API key has to work from curl, a cron job, or a backend — so it cannot depend on your browser being open. That means the server holds your encrypted refresh token, and can therefore use your account. It is encrypted at rest and never pooled across users, but it is custody, and that is the trade.
Connect an account and make your first call
Sign in, connect ChatGPT, create a key. Your first request usually works on the first try.
Using it from code
The OpenAI SDKs only need a different base URL and key. Responses are OpenAI-shaped, including errors.
import OpenAI from "openai"
const client = new OpenAI({
baseURL: "https://api.zap.dscv.me/v1",
apiKey: process.env.OPENAI_OAUTH_KEY,
})
const stream = await client.chat.completions.create({
model: "gpt-5.5",
messages: [{ role: "user", content: "Hello" }],
stream: true,
})
for await (const part of stream) {
process.stdout.write(part.choices[0]?.delta?.content ?? "")
}ChatGPT is only the first provider
ZapLLM is built to speak for more than one upstream, and the next steps are already planned.
More OAuth providers
Sign-in with other AI providers is coming, using the same connect-once, get-an-endpoint model. Your other plans, same idea.
Bring your own keys
Have API keys from free tiers of other providers? Add them, and ZapLLM merges several keys from a single provider into one endpoint that spreads requests across them.
One endpoint, every model
All of your connected providers behind a single OpenAI-compatible URL — pick a model, not a provider, and the routing just happens.