Skip to content
Use cases

What developers build on a $0-inference API

Six things people point the endpoint at. Each one comes with code that runs as-is, the volume it assumes, and what the same month would cost at list prices elsewhere. No customer metrics on this page — we'll publish real routing stats when there's enough volume for them to mean something.

The part every case shares

  • One OpenAI-compatible endpoint — change base_url and api_key
  • model: "auto" → ZeroOptimize™ picks the best free model per request, with failover
  • Inference cost $0 on every plan; plans differ by calls per day
  • Trial: 100 calls/day for 7 days. Lifetime: 10,000 calls/day, $99 once

Right now a request would go to Qwen: Qwen3.8 27B (free).

# routing right now

1. Qwen: Qwen3.8 27B (free)AlibabaACTIVE
2. Google: Gemma 4 31B (free)GoogleSTANDBY
3. Google: Gemma 4 26B A4B (free)GoogleSTANDBY
4. Z.ai: GLM 5.2 (free)Z.aiSTANDBY
5. Dots Studio: Dots3-Note Preview (free)dots-studioSTANDBY

01 · Developers using Cline, Roo Code, Continue or Aider

Backend for your AI coding assistant

Editor assistants burn tokens: every edit ships thousands of tokens of context. On a paid API that's the biggest line on the bill; on a single free provider you hit its rate limit by mid-morning.

How it runs here

Point the editor at the endpoint with model "auto". Each request goes to the best free coding model available right now; when one rate-limits, the next answers. No plugin, no adapter.

A month at this volume

Assumes 200 requests/day · 4,000 tokens in · 800 out → 24.0M in, 4.8M out, 6,000 calls.

GPT-4o mini at list price$6.48/mo
GPT-4o at list price$108/mo
ZeroLimitAI Lifetime$0/mo · $99 once

200 calls/day fits the Lifetime quota (10,000/day). List prices as of 2026-09; check the vendor.

Setup for Cline, Roo, Continue, Aider, Open WebUI
bash
# Continue · ~/.continue/config.json
{
  "models": [{
    "title": "ZeroLimitAI",
    "provider": "openai",
    "model": "auto",
    "apiBase": "https://www.zerolimitai.com/api/v1",
    "apiKey": "zlai_your_key"
  }]
}

02 · Indie products and small teams

Support bot for Telegram, Discord or your site

A bot that answers from your docs is cheap to build and expensive to run once real users show up — and it must keep working at 3 a.m. without you watching a provider dashboard.

How it runs here

Your bot code owns each user's conversation and memory; every turn is one chat completion with model "auto". Failover is inside the endpoint, so an upstream outage is a slower answer, not a dead bot. Serving your own end users through the API is within fair use.

A month at this volume

Assumes 1,000 requests/day · 1,500 tokens in · 300 out → 45.0M in, 9.0M out, 30,000 calls.

GPT-4o mini at list price$12/mo
GPT-4o at list price$203/mo
ZeroLimitAI Lifetime$0/mo · $99 once

1,000 calls/day fits the Lifetime quota (10,000/day). List prices as of 2026-09; check the vendor.

python
from openai import OpenAI
client = OpenAI(base_url="https://www.zerolimitai.com/api/v1", api_key="zlai_your_key")

def reply(history: list[dict], user_text: str) -> str:
    r = client.chat.completions.create(
        model="auto",
        messages=[{"role": "system", "content": DOCS_SYSTEM_PROMPT}, *history,
                  {"role": "user", "content": user_text}],
    )
    return r.choices[0].message.content

03 · Ops, research and legal teams

Summarise documents in a pipeline

Hundreds of PDFs, tickets or transcripts a day, each a few thousand tokens in and a paragraph out. Input tokens dominate the cost, and the job is bursty.

How it runs here

Stream the text in, ask for a fixed-shape summary, store it. Long-context free models handle 8k-token inputs comfortably; "auto" prefers the ones that are answering fast today.

A month at this volume

Assumes 500 requests/day · 8,000 tokens in · 500 out → 120.0M in, 7.5M out, 15,000 calls.

GPT-4o mini at list price$23/mo
GPT-4o at list price$375/mo
ZeroLimitAI Lifetime$0/mo · $99 once

500 calls/day fits the Lifetime quota (10,000/day). List prices as of 2026-09; check the vendor.

python
r = client.chat.completions.create(
    model="auto",
    messages=[
        {"role": "system", "content": "Summarise in 5 bullets. Then list open questions."},
        {"role": "user", "content": document_text[:32000]},
    ],
)
summary = r.choices[0].message.content
print(r.model)  # the model that actually answered — log it

04 · Internal tools, Slack bots, help centres

Q&A over your own docs (RAG)

You retrieve the right passages yourself; you just need a model to answer from them, reliably, thousands of times a month, without the per-token meter running.

How it runs here

Retrieve with your vector store of choice, put the passages in the prompt, call "auto". The endpoint is OpenAI-compatible, so LangChain and LlamaIndex work unchanged.

A month at this volume

Assumes 300 requests/day · 3,000 tokens in · 400 out → 27.0M in, 3.6M out, 9,000 calls.

GPT-4o mini at list price$6.21/mo
GPT-4o at list price$104/mo
ZeroLimitAI Lifetime$0/mo · $99 once

300 calls/day fits the Lifetime quota (10,000/day). List prices as of 2026-09; check the vendor.

python
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(model="auto", base_url="https://www.zerolimitai.com/api/v1", api_key="zlai_your_key")
answer = llm.invoke(f"Answer from these passages only:\n{passages}\n\nQ: {question}")

05 · Marketing and e-commerce

Drafts at volume: product copy, emails, posts

First drafts for hundreds of SKUs or campaigns. Output-heavy, and output tokens are the expensive side of every paid API.

How it runs here

Generate drafts with "auto", keep humans on the edit. Free frontier models write well enough for a draft; the router keeps you on whichever is best this week without touching code.

A month at this volume

Assumes 100 requests/day · 1,000 tokens in · 1,200 out → 3.0M in, 3.6M out, 3,000 calls.

GPT-4o mini at list price$2.61/mo
GPT-4o at list price$44/mo
ZeroLimitAI Lifetime$0/mo · $99 once

100 calls/day fits the Lifetime quota (10,000/day). List prices as of 2026-09; check the vendor.

typescript
import OpenAI from "openai";
const client = new OpenAI({ baseURL: "https://www.zerolimitai.com/api/v1", apiKey: "zlai_your_key" });

const draft = await client.chat.completions.create({
  model: "auto",
  messages: [{ role: "user", content: `Write a 120-word product description for: ${sku}` }],
});

06 · Data and platform teams

Classify, tag and extract at scale

Short prompts, tiny outputs, huge counts: routing tickets, tagging reviews, pulling fields into JSON. Cheap per call anywhere — until it's 5,000 calls a day, every day.

How it runs here

Ask for a strict JSON shape and validate it. At this volume the daily quota matters more than tokens: 5,000/day fits Lifetime's 10,000; past that, Business.

A month at this volume

Assumes 5,000 requests/day · 600 tokens in · 100 out → 90.0M in, 15.0M out, 150,000 calls.

GPT-4o mini at list price$23/mo
GPT-4o at list price$375/mo
ZeroLimitAI Lifetime$0/mo · $99 once

5,000 calls/day fits the Lifetime quota (10,000/day). List prices as of 2026-09; check the vendor.

python
r = client.chat.completions.create(
    model="auto",
    messages=[
        {"role": "system", "content": 'Reply with JSON only: {"category": string, "sentiment": "pos"|"neg"|"neu"}'},
        {"role": "user", "content": review_text},
    ],
)
data = json.loads(r.choices[0].message.content)

What this page doesn't claim

The volumes above are assumptions, stated next to each result, not measurements of anyone's traffic. The cost lines use vendor list prices, which change. And "free" means free models: quality is what the best open models offer this week — see the live chain above and try one prompt on three of them at /tools/compare.

Once the API carries enough volume, this page will show real routing stats per use case: models used, p50/p95 latency, failover rate.

Try it on your own workload

Free key, no card, 100 calls/day for 7 days. Wire it in, log response.model, decide with your own numbers.

Stop paying per token.

One endpoint. $0 inference.

Free API key in a minute — no card. Lifetime is $99.