DEV Community: Daniel Dong

The fastest way to go from "what's an AI API" to "my app uses four models."

Daniel Dong — Wed, 12 Aug 2026 14:29:35 +0000

The fastest way to go from "what's an AI API" to "my app uses four models."

Step	What happens
Step 1: Playground	No signup. 15 models. Pick one. Type words. See response.
Step 2: Register	GitHub → authorize → done. 5 seconds.
Step 3: Onboarding	API key + curl + Python code. Copy, paste, run.
Step 4: Production	Same code. Different model string.

Step 1 → Step 2: The one click that matters

No email. No password. No 6-digit code. You try the playground, you
like it, you click GitHub → authorize → you have a key. Five seconds.

Before GitHub OAuth, registration was 6 steps. 1.4% completion rate.
After: one click. 19% conversion from playground to registered user.

Step 2 → Step 3: The bridge

After login, you don't land on an empty dashboard. You land on a page
that says "Your account is ready." Your API key is right there. A curl
command you can paste into a terminal. Python SDK code to copy.

curl https://aibridge-api.com/v1/chat/completions \
  -H "Authorization: Bearer mb-xxx" \
  -d '{"model":"deepseek-chat","messages":[{"role":"user","content":"Hello"}]}'

30 seconds from login to first response. The 68% drop-off between
registration and first API call? That's the gap this page closes.

Step 3 → Step 4: The one-string change

Once you've run the curl command and seen it work, production is this:

import openai
client = openai.OpenAI(
    api_key="mb-xxx",
    base_url="https://aibridge-api.com/v1"
)

# 90% of traffic — $0.27/M
client.chat.completions.create(model="deepseek-chat", messages=msgs)

# Multilingual work
client.chat.completions.create(model="qwen-max", messages=msgs)

# Deep reasoning
client.chat.completions.create(model="glm-4-plus", messages=msgs)

# 1M context, always thinks
client.chat.completions.create(model="kimi-k3", messages=msgs)

Same import openai. Same .create() call. Same response format.
The only thing that changes is the model string. No new SDKs.
No new environment variables. No new accounts.

The stuff that supports all of this
Prompt library — 24 ready-to-use prompts. Six categories. "Find
bugs → Kimi K3." "Translate → Qwen Max." One click fills the
playground.

Dashboard — usage bar that goes from polite to urgent. Blue below
50%, orange at 80%, red flashing at 90%. The upgrade button gets
harder to miss exactly when you need to act.

Anti-bot protection — 5 lines of in-memory rate limiting took
verification endpoint abuse from 2,600 requests/day to zero.

Free tier: 500K tokens/month. No credit card.

→ aibridge-api.com/playground.html (step 1)
→ aibridge-api.com/prompts.html (if you need ideas)
→ aibridge-api.com/register.html (step 2, one click)

I migrated my codebase from 1 AI provider to 4. Here's every line I changed.

Daniel Dong — Tue, 11 Aug 2026 11:57:55 +0000

I migrated my codebase from 1 AI provider to 4. Here's every line I changed.

# Before
client = openai.OpenAI(
    api_key="sk-deepseek-xxx",
    base_url="https://api.deepseek.com/v1"
)
client.chat.completions.create(model="deepseek-chat", messages=msgs)

# After
client = openai.OpenAI(
    api_key="mb-xxx",
    base_url="https://aibridge-api.com/v1"
)
client.chat.completions.create(model="deepseek-chat", messages=msgs)

That's the migration. One string in the base_url. One string in the
api_key. The import openai, the .create() signature, the response
parsing, the streaming logic, the error handling — all unchanged.

But now I can do this:

# Fast and cheap ($0.27/M) — 90% of traffic
client.chat.completions.create(model="deepseek-chat", messages=msgs)

# Multilingual, 128K context
client.chat.completions.create(model="qwen-max", messages=msgs)

# Complex Chinese reasoning
client.chat.completions.create(model="glm-4-plus", messages=msgs)

# 1M context, always reasoning
client.chat.completions.create(model="kimi-k3", messages=msgs)

Four providers. Four different strengths. Same function call. Same
response format. No SDK switches. No new environment variables.

The routing pattern that saves money

Most apps don't need the most powerful model for every request. My
app does classification, summarization, simple generation, and the
occasional complex debugging session. Four types of work. Four models.

def pick_model(task):
    return (
        "deepseek-chat" if task in ("classify","summarize","simple")
        else "qwen-max" if task in ("translate",)
        else "glm-4-plus" if task in ("reason",)
        else "kimi-k3" if task in ("review_codebase",)
        else "deepseek-chat"
    )

client.chat.completions.create(model=pick_model(task), messages=msgs)

Before routing: every request hit the 7/Mmodel.Monthlybill: 700.
After routing: 90% of requests hit the 0.27/Mmodel.Bill: 120.

Same quality on classification and summarization. The cheap model
is indistinguishable from the expensive one on those tasks. The only
difference is the price tag.

Kimi K3: the one worth upgrading for

When a task needs real reasoning power and a massive context window,
K3 is the only model I reach for. 1M token context — I paste entire
modules and ask it to trace race conditions through the call chain.
It reads every line, runs an automatic reasoning pass, then gives me
locations with suggested fixes.

No "think mode ON/OFF" toggle. No prompt engineering. No configuration.
Just send the prompt. K3 thinks, then answers.

The supporting cast

*Free playground *— 15 models, 10 requests/day, no signup. Try K3
without creating an account. If you like it, GitHub OAuth gets you a
key in five seconds.

Prompt library — 24 ready-to-use prompts across 6 categories.
Each one recommends the right model. "Find bugs → Kimi K3." "Translate
→ Qwen Max." One click fills the playground.

Onboarding — after login, your API key is on the screen with a
copy button. A curl command you can paste immediately. Python SDK
code. 30 seconds to first response.

Dashboard — usage bar that escalates. Polite below 50%. Orange at
80%. Red and flashing at 90%. The upgrade button gets harder to miss
exactly when you need to act.

Free tier: 500K tokens/month. No credit card. One import openai.
One endpoint. 15 models.

→ aibridge-api.com/playground.html
→ aibridge-api.com/prompts.html

24 prompts. 6 categories. One static HTML file. Zero backend changes.

Daniel Dong — Tue, 11 Aug 2026 02:19:45 +0000

24 prompts. 6 categories. One static HTML file. Zero backend changes.

Here's why I built a prompt library instead of more API features.

The problem I couldn't ignore

68% of my users registered, got an API key, and then... nothing.
Zero API calls. Zero tokens. They had 15 AI models at their
fingertips and never used a single one.

I checked the logs. I checked the docs. The API was working. The docs
were clear. The key was active. People just didn't know what to ask.

A blank input box is not onboarding. It's a test. And most people
fail it — not because they can't think of something, but because
they don't know where to start.

What I built

A page with 24 ready-to-use prompts organized in 6 categories:

💻 Code — Find bugs, refactor, explain, add error handling
📝 Content — Summarize, translate, rewrite
🏷️ Classification — Sentiment, categorize tickets, detect language
🔍 Analysis — Compare approaches, review API design, debug logs
✍️ Writing — Write API docs, README, commit messages
📊 Data — Generate SQL, parse JSON, convert CSV schema

Each card does three things:

Shows a prompt — what to paste into the API
Recommends a model — Kimi K3 for code review (1M context, always reasoning), DeepSeek for classification ($0.27/M), Qwen for translation
Gives you one-click actions — Try in Playground (pre-fills the model, system prompt, and message), Copy as curl, Copy as Python

One click from browsing to running. No guesswork.

Why it works

The prompt library solves three problems at once:

Problem 1: "I don't know what to ask."
→ Here are 24 things. Pick one.

Problem 2: "I don't know which model to use."
→ Every prompt says which model. You'll learn by doing.

Problem 3: "I don't know how to call the API."
→ Copy as curl. Copy as Python. Paste. Run. Done.

It's also the best kind of content — it's useful whether or not you
use the product. Someone could copy a prompt, paste it into any
OpenAI-compatible endpoint, and it works. But if they do it through
our playground, they experience the full product in one click.

The numbers

The entire prompt library is one HTML file. 18KB. No new API routes.
No database table. No backend changes. Took half a day to build and
ship.

It lives at aibridge-api.com/prompts.html. Link in the playground
header. Link in the dashboard nav. Accessible whether you're logged
in or not.

What's behind the prompts

15 Chinese AI models. One OpenAI-compatible endpoint. Free playground
with no signup — 10 requests/day, all models. GitHub OAuth login in
one click. Instant onboarding after login with your key, a curl
command, and Python code all on one page.

import openai
client = openai.OpenAI(
    api_key="mb-xxx",
    base_url="https://aibridge-api.com/v1"
)
client.chat.completions.create(model="kimi-k3", messages=messages)

Free tier: 500K tokens/month. No credit card.

→ aibridge-api.com/prompts.html
→ aibridge-api.com/playground.html

I stopped asking people to sign up for my API. I asked them to try it instead.

Daniel Dong — Mon, 10 Aug 2026 02:25:21 +0000

I stopped asking people to sign up for my API. I asked them to try it instead.

One sentence. One button. One page. That change moved every metric I care about.

Before: Sign up first

Landing page → "Get Started Free" → Email → Password →
Verify inbox → 6-digit code → API key → Dashboard

Six steps before the developer feels a single token of value.
68% of people who registered never sent an API request. Not because
the API was bad. Because the gap between "I have an account" and
"I just made it do something" was a chasm.

After: Try first

Landing page → "Try Playground →" → Pick a model → Type a prompt →
Response in 800ms → "Want your own key? One click →"

No email. No password. No verification. No dashboard you don't know
how to use. Just a text box and a Send button.

When they like what they see, GitHub OAuth gets them a key in five
seconds. When they register, an onboarding page hands them their key,
a curl command, and Python SDK code — all copyable — before they
ever see the dashboard.

What changed

Metric	Before	After
Registration → first API call	32%	35% (and climbing)
Visitor → registration	2.5%	19%
Dormant users (0 tokens)	68%	65%
Bot verification requests	2,600/day	0
Pages surfacing value	3	6

The dormant user number is the one I'm watching most closely. 65% is
still too high. But it moved. Three percentage points after deploying
the onboarding page. The prompt library was the next push — 24
ready-to-use prompts organized by task, each one showing which model
to use and pre-filling the playground in one click.

What I built to support this

The playground — 15 models, 10 free requests/day, no login. If
you use it and walk away, that's fine. If you use it and want more,
registration is one click. Not a form. Not a funnel. An invitation.

The onboarding page — after login, you see your API key, a curl
command you can paste immediately, and Python SDK code. Copy, paste,
run. 30 seconds to first response. No docs. No guesswork.

The prompt library — 24 prompts. Six categories. "Find bugs in this
code → Kimi K3." "Translate to Chinese → Qwen Max." "Write unit tests
→ DeepSeek." Every card has a "Try in Playground" button that fills
the model, system prompt, and message in one click.

The dashboard — not just numbers. A usage bar that escalates.
Polite below 50%. Orange at 80%. Red and flashing at 90% with a
full-width upgrade button. You notice it exactly when you need to act.

The anti-bot layer — 5 lines of in-memory rate limiting took
verification endpoint abuse from 2,600 requests/day to zero. Not a
feature users see, but one they benefit from every time the server
responds quickly.

The model powering it

One import openai. One endpoint. 15 Chinese AI models.

import openai
client = openai.OpenAI(
    api_key="mb-xxx",
    base_url="https://aibridge-api.com/v1"
)
client.chat.completions.create(model="kimi-k3", messages=messages)
client.chat.completions.create(model="deepseek-chat", messages=messages)
client.chat.completions.create(model="qwen-max", messages=messages)

K3: 1M context, always reasoning. DeepSeek: $0.27/M, fast and cheap.
Qwen: multilingual. GLM-4 Plus: complex Chinese reasoning. Same SDK.
Same response format. Change one string to switch models.

The principle

Every page in my product answers exactly one question:

Landing     → "What is this?"
Playground  → "Can I try it?"
Onboarding  → "How do I start?"
Dashboard   → "How much have I used?"
Prompts     → "What should I ask?"
Pricing     → "What does it cost?"

If a page answers zero questions, it doesn't exist. If it answers two,
I split it. Users don't read — they scan for the one thing they need.

Free tier: 500K tokens/month. No credit card.

→ aibridge-api.com/playground.html (try all 15 models, no signup)
→ aibridge-api.com/prompts.html (24 prompts, no signup needed)

First I killed the signup wall. Then the bots came.

Daniel Dong — Sun, 09 Aug 2026 15:08:50 +0000

First I killed the signup wall. Then the bots came.

So I killed them too.

Part 1: The wall

Three weeks ago I removed the signup wall from my API product. Instead
of email → password → verification code → API key, visitors landed on
a free playground. 15 models. 10 requests/day. No login. No email.
No friction.

It worked. Registrations jumped from 1 per week to 14. 86% of new
signups were real Gmail accounts. Conversion from playground to
registration hit 19%.

Then something else showed up.

Part 2: The bots

I checked the server logs and found /auth/send-verification-code
getting hammered. 2,600 requests per day. Every single day.

Jul 17: 2,634
Jul 18: 2,713
Jul 19: 2,642
Jul 20: 2,550
Jul 21: 2,745

That's 47-60% of all server traffic. The bots were hitting the
verification endpoint with disposable emails, rotating IPs, never
actually completing registration. Just burning CPU cycles and
wasting bandwidth.

At first I thought "who cares, they're not getting through." But
2,600 requests/day isn't free. On a 1-core VPS, that's real load.
And it makes real traffic analysis impossible when half your data
is noise.

Part 3: The fix (5 lines)

# Before: no rate limit
@app.post("/auth/send-verification-code")
async def send_verification_code(request: Request):
    email = body.get("email")
    # generate code, send email...

# After: one check
@app.post("/auth/send-verification-code")
async def send_verification_code(request: Request):
    client_ip = request.client.host
    now = time.time()

    with _verify_code_rate_lock:
        last_req = _verify_code_rate_limits.get(client_ip, 0)
        if now - last_req < 60:
            raise HTTPException(429, "Too many requests")
        _verify_code_rate_limits[client_ip] = now

    email = body.get("email")
    # generate code, send email...

That's it. A dictionary. A lock. A timestamp check. 1 request per
minute per IP. No Redis. No external rate limiter. No database.
Five lines of in-memory Python.

I also added a domain blocklist. Ten seconds of grep showed the top
abusers: disposable email domains like mailinator, guerrillamail,
and a few others. Blocked at registration.

Part 4: The result

Week	Verification requests/day	Server load
Jul 17-23 (before)	~2,600	47-60% bot traffic
Jul 24-31 (rate limit deployed)	~2,500	bot slowed but IPs rotated
Aug 1-4 (rate limit + domain block)	~1,600 → 0	decay then silence
Aug 5-9 (now)	0-2	bot traffic eliminated

From 17,000 bot requests per week to zero. Five lines of code. One
domain blocklist.

The pattern

This is the second time I've learned the same lesson: you don't need
a complex solution for a simple problem.

Removing the signup wall wasn't a multi-month redesign. It was one
static HTML page with an 80-line FastAPI endpoint that bypassed auth.

Killing the bots wasn't a rate-limiting service or a CAPTCHA
integration. It was five lines of in-memory rate limiting and a set
of blocked domains.

Both times the fix was simpler than the problem. Both times the
impact was immediate and measurable.

The most effective infrastructure changes I've made to this product
weren't the big features. They were the small, targeted interventions
that removed friction for real users and added friction for bad ones.

AIBridge — 15 Chinese AI models behind one OpenAI-compatible endpoint.
Free playground with no signup. GitHub OAuth login in one click. No
bots wasting your bandwidth (or ours).

→ aibridge-api.com/playground.html (15 models, no signup)
→ aibridge-api.com/prompts.html (24 ready-to-use prompts)

The fastest way to try an AI model is to not sign up for it.

Daniel Dong — Sun, 09 Aug 2026 08:12:25 +0000

The fastest way to try an AI model is to not sign up for it.

No email. No password. No 6-digit code. No "check your inbox."

Just open the playground, pick a model, type a prompt, and watch the
response come back. If it works for you, registration is one click
away. If it doesn't, you lost 30 seconds.

Why every AI product should work this way

AI models are not like databases. You can't evaluate them from a
pricing table or a benchmark chart. You have to use them. Your prompt,
your data, your use case. Everything else is someone else's opinion.

That's why the playground is at the center of AIBridge. Not the docs.
Not the SDK. Not the blog. The thing where you type words and the
model responds.

What's behind that one prompt

import openai
client = openai.OpenAI(
api_key="mb-xxx",
base_url="https://aibridge-api.com/v1"
)

15 Chinese AI models. Same import openai. Same .create() signature.
Same response format. Different model string.

Model	Strength	Price
deepseek-chat	Fast, cheap, general purpose	$0.27/M
qwen-max	Multilingual, 128K context	$2.80/M
glm-4-plus	Complex reasoning, Chinese	$7.10/M
kimi-k3	1M context, always reasoning	$3/M

You don't need four API keys. You don't need four SDKs. You need one
endpoint and four model strings.

What else comes with it

24 ready-to-use prompts. Six categories. Code review, content,
classification, analysis, writing, data. Each one says which model
to use and how. Click "Try in Playground" and it fills everything in
for you. No more staring at a blank input box.

GitHub login. Click GitHub → authorize → dashboard. Five seconds.
No form. No verification code. Same 500K free tokens.

Instant onboarding. After login, your API key is on the screen
with a copy button next to a curl command and Python SDK code. Copy,
paste, run. First response in 30 seconds.

Smart dashboard. Usage bar that quietly shows your balance, then
loudly tells you when it's time to upgrade. Blue below 50%, orange at
80%, red flashing at 90%. The upgrade button gets harder to miss
exactly when you need to see it.

Free tier: 500K tokens/month. No credit card.

→ aibridge-api.com/playground.html (15 models, no signup)
→ aibridge-api.com/prompts.html (24 prompts, no signup needed)

The first thing visitors see on AIBridge is a "Try Playground " button. Not "Get Started." Not "Sign Up Free."

Daniel Dong — Sat, 08 Aug 2026 03:25:45 +0000

The first thing visitors see on AIBridge is a "Try Playground →" button.
Not "Get Started." Not "Sign Up Free." Try the playground.

Behind that button is a page with 15 AI models, no login, and 10 free
requests per day. You pick a model, type a prompt, see the response.
If you like it, registration is one click via GitHub — no email, no
password, no verification code.

What happens after that click

Login lands you on an onboarding page, not a dashboard. Your API key is
right there with a copy button. A curl command you can paste and run
immediately. Python SDK code. Three things on one screen. 30 seconds
from login to first API response.

From there you either go to the dashboard (usage tracking, upgrade
options) or the prompt library (24 ready-to-use prompts organized
by category — code review, translation, classification, debugging).

Every page answers exactly one question:

Landing page → "What is this?"
Playground → "Can I try it?"
Onboarding → "How do I start?"
Dashboard → "How much have I used?"
Prompt library → "What should I ask?"

The model behind all of it

One OpenAI-compatible endpoint. 15 Chinese AI models — DeepSeek,
Qwen, GLM, Kimi K3 — all behind the same import openai as always.

import openai
client = openai.OpenAI(
    api_key="mb-xxx",
    base_url="https://aibridge-api.com/v1"
)
client.chat.completions.create(model="kimi-k3", messages=messages)

Change the model string. Nothing else changes.

K3 has a 1M token context window and always-on reasoning — no toggle
needed. DeepSeek costs $0.27/M. Qwen handles multilingual. GLM-4 Plus
excels at complex Chinese reasoning.

Why the homepage doesn't push signup

Most API products optimize for registration. They put the signup form
front and center, push the "Get Started" button, measure conversion by
how many people fill out the form.

I optimized for first use. The first time someone types a prompt into
the playground and sees a response come back — that's the conversion
event. Registration happens after, not before.

Since making that change, registration-to-signup conversion sits around
19%. The average for SaaS signup walls is around 2-4%.

Let people use the thing first. Ask them to commit second.

Free tier: 500K tokens/month. No credit card.

→ aibridge-api.com(Playground first, signup second)
→ aibridge-api.com/prompts.html (24 prompts, no signup needed)

My API product has 5 pages. Here's what each one does and why.

Daniel Dong — Fri, 07 Aug 2026 02:36:12 +0000

My API product has 5 pages. Here's what each one does and why.

Not the backend. Not the gateway code. The 5 pages users actually see.

1. The landing page — one button, not three

Every API product landing page looks the same: hero text, feature grid,
pricing table, three CTA buttons.

Mine has one button that matters: "Try Playground →"

Before that was the main CTA, registration sat at the top and conversion
was 2.5%. Swapped the order. Playground first, signup second. Visitors
land, type a prompt, see a response, then register. Conversion hit 19%.

The lesson: let people use the thing before you ask them to commit to it.

2. The playground — no login, no friction

15 models, 10 free requests per day, no signup. Pick a model, type a
prompt, get a response. If you like it, "Get your API key →" is one
click away.

The most important feature isn't the model selection or the markdown
rendering. It's the fact that there's no wall. No email. No password.
No "create an account to continue." Just type and go.

3. The onboarding page — 30 seconds to first call

After login, instead of an empty dashboard, you land on a page that
shows your API key, a curl command you can paste and run immediately,
and Python SDK code to copy.

30 seconds from login to first API response. For the 68% of users who
registered but never made a single call, this is the bridge between
"I have an account" and "it works."

4. The dashboard — polite, then urgent

Usage bar that escalates. Below 50%: small blue bar, subtle upgrade
button. Above 80%: orange bar, "Unlock 10x more →". Above 90%: red
flashing bar, "Only 15K tokens left," full-width upgrade button.

The same data. Different urgency. You notice it exactly when you need
to act — not before, not after.

5. The prompt library — 24 things to do right now

68% of users made zero API calls. Not because the API was hard. Because
a blank input box doesn't tell you what to ask.

The prompt library says: here's 24 things you can do right now. Find
bugs → Kimi K3. Translate → Qwen Max. Write tests → DeepSeek. Each
card has a "Try in Playground" button that pre-fills the model, system
prompt, and user message. One click from browsing to running.

6 categories. 24 prompts. One static HTML file. No backend changes.

Five pages. Each one answers a different question:

"What is this?" → Landing page
"Can I try it?" → Playground
"How do I start?" → Onboarding
"How much have I used?" → Dashboard
"What should I ask?" → Prompt library

The gateway code does the heavy lifting. But the pages do the
conversion. And conversion is what turns a functional API into
something people pay for.

AIBridge — 15 Chinese AI models behind one OpenAI-compatible endpoint.
Free tier: 500K tokens/month. GitHub login. Instant onboarding.
Prompt library. Playground with no signup.

→ aibridge-api.com/playground.html
→ aibridge-api.com/prompts.html

I shipped a prompt library. Not because it's sexy. Because people were staring at a blank input box.

Daniel Dong — Thu, 06 Aug 2026 15:39:25 +0000

I shipped a prompt library. Not because it's sexy. Because people were staring at a blank input box.

My API gateway has 15 models. Kimi K3 with 1M context. DeepSeek at
$0.27/M. Qwen for multilingual. GLM-4 Plus for complex reasoning.

Users signed up, got their API key, opened the dashboard... and then
did nothing. 68% of registered users had zero API calls.

They weren't confused about the API. They were confused about what
to ask. The input box was empty. Their mind was too.

What I built

A static HTML page. 6 categories. 24 prompts. No backend. No database.
No API routes. One file.

📚 Prompt Library
─────────────────────────────────────

💻 Code
├── Find bugs in this code → Try with Kimi K3
├── Refactor for readability → Try with Kimi K3
├── Explain this function → Try with GLM-4 Plus
├── Add error handling → Try with Kimi K3
└── Generate unit tests → Try with DeepSeek

📝 Content
├── Summarize an article → Try with DeepSeek
├── Translate to Chinese → Try with Qwen Max
├── Rewrite in formal tone → Try with Qwen Max
└── ...

🏷️ Classification
🔍 Analysis
✍️ Writing
📊 Data

Each prompt has three buttons:

🎯 Try in Playground — opens a new tab with the model pre-selected,
system prompt filled in, user message ready to send. One click from
"what do I ask" to "oh, it works."

📋 Copy as curl — complete command with the prompt and recommended
model. Replace the API key placeholder and run.

🐍 Copy as Python — OpenAI SDK code with the same prompt.
Paste into your project and start iterating.

Why this matters

Most API products assume users know what they want to build. That's
wrong. Most users know they might want to build something, but
they don't know where to start.

A blank input box is the worst onboarding experience in developer
tools. It says "I'm ready when you are" but the user hears "figure
it out yourself."

A prompt library says "here's 24 things you can do right now.
Pick one. See it work. Then build your own."

The model tip built into every prompt

Every card recommends a specific model. Find bugs → Kimi K3
(1M context, always reasoning). Translate → Qwen Max. Generate
tests → DeepSeek ($0.27/M). Classification → DeepSeek.

Users don't need to know which model is best for which task. The
prompt library teaches them by doing. After trying a few, they
naturally start matching tasks to models.

What's behind it

The rest of the product hasn't changed. 15 Chinese AI models behind
one OpenAI-compatible endpoint. Free playground with no signup.
GitHub OAuth in one click. Instant onboarding after login — API key,
curl command, Python code, all copyable in 30 seconds.

Free tier: 500K tokens/month. No credit card.

→ aibridge-api.com/prompts.html (24 prompts, 6 categories)
→ aibridge-api.com/playground.html (try all 15 models, no signup)

Try 15 AI models without signing up. No email. No password. No credit card.

Daniel Dong — Thu, 06 Aug 2026 15:11:57 +0000

Try 15 AI models without signing up. No email. No password. No credit card.

That's what our playground does. You land, pick a model, type a prompt.
The response comes back in under a second. You like it? Registration is
one click away — via GitHub OAuth, no form to fill.

The playground

10 free requests per day. Every model available. Kimi K3 with its
1M context and always-on reasoning. DeepSeek at $0.27/M for quick
tasks. Qwen for multilingual. GLM-4 Plus for complex reasoning.

From playground to production

When you're ready, grab an API key. GitHub OAuth — one click, five
seconds. Then you land on an onboarding page that hands you everything:

🔑 API key: mb-xxx [📋 Copy]

curl https://aibridge-api.com/v1/chat/completions
-H "Authorization: Bearer mb-xxx"
-d '{"model":"deepseek-chat",...}' [📋 Copy]

import openai [📋 Copy]
client = openai.OpenAI(...)
client.chat.completions.create(...)

Copy, paste, run. 30 seconds from login to first response.
No reading docs. No environment variables. No guesswork.

Production mode

Same OpenAI-compatible interface you already know:

import openai
client = openai.OpenAI(
    api_key="mb-xxx",
    base_url="https://aibridge-api.com/v1"
)
client.chat.completions.create(model="kimi-k3", messages=messages)
client.chat.completions.create(model="deepseek-chat", messages=messages)
client.chat.completions.create(model="qwen-max", messages=messages)

Same library. Same .create(). Different model string.
Streaming, function calling, JSON mode — all work out of the box.

Free tier: 500K tokens/month. Enough to run classification,
summarization, and simple generation for a small production app.
Dashboard shows exactly where you stand, and the upgrade button
gets harder to miss as you approach your limit.

→ aibridge-api.com/playground.html (try all 15 models, no signup)
→ aibridge-api.com/register.html (GitHub login, one click)

I migrated my app from one AI provider to four. Here's the code change.

Daniel Dong — Wed, 05 Aug 2026 10:45:23 +0000

I migrated my app from one AI provider to four. Here's the code change.

# Before: one provider, one model
openai.OpenAI(
    api_key="sk-deepseek-xxx",
    base_url="https://api.deepseek.com/v1"
)

# After: four providers, 15 models
openai.OpenAI(
    api_key="mb-xxx",
    base_url="https://aibridge-api.com/v1"
)

That's it. One string changed. Zero new imports. Zero SDK rewrites.
Suddenly I have DeepSeek, Qwen, GLM, and Kimi K3 behind the same endpoint.

Why I needed more than one model

My app does three things: classify user input, translate content
to Chinese, and occasionally debug customer-reported issues.

Sending everything to deepseek-chat ($0.27/M) worked. But the
debugging tasks needed more reasoning power. The translations
needed better multilingual support. I was using one model for
three very different jobs.

Now I route by task type:

model = (
    "deepseek-chat" if task == "classify" else     # $0.27/M
    "qwen-max"      if task == "translate" else     # multilingual
    "kimi-k3"       if task == "debug" else         # 1M context + always thinks
    "deepseek-chat"                                  # default
)

client.chat.completions.create(model=model, messages=messages)

Same code. Same bill. Different model for different work.

The K3 difference

Kimi K3 is the one I reach for when the question is hard and the
context is large. 1M token window — I've pasted entire modules and
asked it to find race conditions. It reads every line, runs a
reasoning pass without being told, then gives me locations with
suggested fixes.

No "think step by step." No reasoning toggle. Just send the prompt.

What made this easy

GitHub OAuth — one click to register. Five seconds.
Instant onboarding — after login: API key + curl example + Python code, all copyable. 30 seconds to first response.
Free playground — 15 models, no signup. 10 requests/day.
Usage dashboard — progress bar that goes from polite to urgent as you approach your free tier limit. Free tier: 500K tokens/month. No credit card.

→ aibridge-api.com/playground.html (try K3, no signup)
→ aibridge-api.com/register.html (GitHub login, one click)

You don't need a new API key. You don't need a new SDK. You don't need to read another provider's documentation.

Daniel Dong — Wed, 05 Aug 2026 02:51:56 +0000

You don't need a new API key. You don't need a new SDK. You don't
need to read another provider's documentation.

You need to change one string.

import openai

# One client. Every model.
client = openai.OpenAI(
    api_key="mb-xxx",
    base_url="https://aibridge-api.com/v1"
)

That's the entire setup. Everything else is picking which model to use:

# Classification, summarization, simple chat → $0.27/M
client.chat.completions.create(model="deepseek-chat", messages=messages)

# Multilingual, structured output → 128K context
client.chat.completions.create(model="qwen-max", messages=messages)

# Complex reasoning → best for Chinese
client.chat.completions.create(model="glm-4-plus", messages=messages)

# 1M context, always thinks before answering
client.chat.completions.create(model="kimi-k3", messages=messages)

Same import. Same .create() signature. Same response format.
Different model string. You already know how to use every single one
because you already know how to use the OpenAI Python SDK.

Why Kimi K3 is different

Most reasoning models make you decide when to think. You toggle
"reasoning mode" on or off. You add "think step by step" to your
system prompt. You optimize for the right amount of compute.

K3 doesn't give you a choice. Every request runs through a reasoning
pass. No toggle. No config. No prompt engineering.

And it has a 1M token context window — 4x what Claude gives you,
8x what GPT-4o gives you. Drop a codebase. Ask a question. K3 reads
every line, thinks about every line, then answers.

What else you get

GitHub login — one click to register. No email. No password.5 seconds from click to dashboard.
Instant onboarding — after login you see your API key, a curl command you can run immediately, and Python SDK code to copy.
Free playground — try all 15 models with no signup. 10 requests per day. If you like it, registration is one click away.
Smart dashboard — usage bar that quietly tells you where you stand, then loudly tells you when it's time to upgrade.

15 Chinese AI models. One OpenAI-compatible endpoint. Free tier:
500K tokens/month. No credit card.

→ aibridge-api.com/playground.html (try K3, no signup)
→ aibridge-api.com/register.html (GitHub login, one click)