Route LLM calls anonymously.

Pool your OpenRouter API key with others. Your calls go through someone else's key. Their calls go through yours. OpenRouter sees a jumble. You only pay for what you use.

Contribute a key How it works

How it works

Three steps. No accounts to manage on multiple platforms, no billing surprises.

Step 1

Contribute

Paste your OpenRouter key. Set a monthly cap (in dollars). Your key is encrypted with AES-256-GCM and added to the shared pool.

Step 2

Earn credit

When others route calls through your key, you earn proxy credit equal to what flowed through. Your real cost: only what was actually used (which OpenRouter bills you directly).

Step 3

Spend anonymously

Make your own LLM calls through other people's keys. They pay OpenRouter for your usage. The pool sprays your traffic across many identities.

How to use it

Use APInonymous like an OpenAI-compatible API endpoint: keep your existing SDK or HTTP client, change the base URL, use your proxy_key as the Authorization: Bearer token, and choose any model OpenRouter supports.

curl

curl https://apinonymous.com/v1/chat/completions \
  -H "Authorization: Bearer apinon_sk_..." \
  -H "Content-Type: application/json" \
  -d '{
    "model": "openai/gpt-4o-mini",
    "messages": [{"role": "user", "content": "Hello!"}],
    "max_tokens": 100
  }'

OpenAI SDK (TypeScript)

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: "apinon_sk_...",                  // your proxy_key
  baseURL: "https://apinonymous.com/v1",
});

const res = await client.chat.completions.create({
  model: "openai/gpt-4o-mini",              // any OpenRouter model
  messages: [{ role: "user", content: "Hello!" }],
});

Python (openai)

from openai import OpenAI

client = OpenAI(
    api_key="apinon_sk_...",
    base_url="https://apinonymous.com/v1",
)

res = client.chat.completions.create(
    model="anthropic/claude-3.5-sonnet",
    messages=[{"role": "user", "content": "Hello!"}],
)

Streaming

const stream = await client.chat.completions.create({
  model: "openai/gpt-4o",
  messages: [{ role: "user", content: "Tell me a story" }],
  stream: true,
});
for await (const chunk of stream) {
  process.stdout.write(chunk.choices[0]?.delta?.content ?? "");
}

Base URL

https://apinonymous.com/v1

Auth

Authorization: Bearer apinon_sk_...

Model names

Use OpenRouter's full id, e.g. openai/gpt-4o

Streaming

Set stream: true like normal

Whoami

GET /v1/me returns your balance

Quotas

60 calls/minute per proxy_key by default

Why this is safe and anonymous

We make a lot of claims about anonymity and security. Here's exactly how the system reduces what can be linked back to any one person.

Your OpenRouter key is encrypted at rest

AES-256-GCM with a master key that lives only in environment variables. It's never sent to any client (including yours after signup). Even if the database were exposed, the OpenRouter keys would remain ciphertext without the master key.

No prompts. No completions. No logging.

We log only metadata for billing: timestamps, token counts, model names, request IDs. Your actual prompts and the model's responses never touch our database, our logs, or our error reporting. They stream through us byte-for-byte.

Each call uses a different key

A 4-layer eligibility filter (sliding history of recent picks, per-pair cooldown, monthly cap, top-N% utilization headroom) plus weighted crypto-random selection mean OpenRouter sees a jumble. Heavy users do not get correlated to a single key.

Two distinct secrets, by design

Your OpenRouter key proves ownership at signup. Your proxy_key is a separate opaque token issued by us, used for both API calls and dashboard login. If your laptop exposes the proxy_key, it can spend your APInonymous balance but cannot impersonate you to OpenRouter directly.

No PII required, ever

No email, no phone number, no payment info. Sign up takes one input: an OpenRouter key. There is no identifying profile for others to dox because we never collect those details in the first place.

Self-hostable, audit-ready

Source code releases publicly soon. The whole stack is one Bun service + one SQLite file. Read it top to bottom, fork it, run your own, and verify how the router behaves.

Anti-extraction by design

New accounts start at zero balance. The 50,000-credit welcome grant stays locked until the account's key handles 10 routed calls from others, so the pool cannot be drained by drive-by accounts.

HMAC-signed sessions, no server-side store

Dashboard sessions are stateless: HMAC-signed cookies that the server verifies cryptographically. No session table to leak. Tampered cookies fail verification with constant-time comparison.

See the Terms of Service for the full legal version.

The economics, with real numbers

No money changes hands between users. Each user pays OpenRouter directly for the capacity that actually flowed through their key. The 2% surcharge funds the operation of the site.

Event	Your OpenRouter bill (real $)	Your proxy balance (credits)
Sign up	$0.00	0
Alice routes $5.00 of GPT-4o through your key	+$5.00	+5,000,000
Bob routes $2.00 of Claude 3.5 Sonnet through your key	+$2.00	+2,000,000
You route $6.86 of GPT-4o through Eli's key (cost + 2% surcharge)	$0.00	~140,000
Net	paid $7.00 to OpenRouter	routed your own ~$6.86 of calls

Diff is the 2% surcharge ($0.14 / 140,000 credits) which funds the operation of the site.

Ready?

Contribute a key