DEV Community: Synap by Linkrra

What an LLM call actually costs in November 2026: open models per 1M tokens

Synap by Linkrra — Wed, 11 Nov 2026 16:28:49 +0000

"$0.017 per million tokens" is a price per token. Your bill is per request, and the two can rank models differently. This post pulls live prices for six open-weight models and prices one realistic workload in realtime and in batch. Then it sends the same request to each model to show where per-token prices mislead.

All numbers were pulled on 2026-11-11 from https://synap402.com/v1/models, the public catalog of Synap (the OpenAI-compatible API we build). Every script below ran today, and the outputs are pasted as they came out, with one cosmetic exception that's noted.

1. The price list, straight from the API

The catalog is public JSON, so you don't need a key to read it. The self-hosted models are the ones with a batch price. Aliases and routers don't have one.

# prices.py: live per-1M-token prices for the self-hosted models, plus a workload estimate
import json, urllib.request

with urllib.request.urlopen("https://synap402.com/v1/models") as r:
    models = json.load(r)["data"]

# Self-hosted models are the ones with a batch price; aliases and routers have none.
own = [m for m in models
       if m.get("pricing", {}).get("basis") == "engine"
       and "batch_prompt_per_million" in m["pricing"]]

REQS, IN_TOK, OUT_TOK = 10_000, 2_000, 500   # the workload to price

print(f"{'model':36} {'in/1M':>8} {'out/1M':>8} {'ctx':>8} {'realtime':>10} {'batch':>9}")
for m in sorted(own, key=lambda m: m["pricing"]["prompt_per_million"]):
    p = m["pricing"]
    rt = REQS * (IN_TOK * p["prompt_per_million"] + OUT_TOK * p["completion_per_million"]) / 1e6
    bt = REQS * (IN_TOK * p["batch_prompt_per_million"] + OUT_TOK * p["batch_completion_per_million"]) / 1e6
    print(f"{m['id']:36} {p['prompt_per_million']:>8} {p['completion_per_million']:>8} "
          f"{m['context_length']:>8} {rt:>10.2f} {bt:>9.2f}")

$ python3 prices.py
model                                   in/1M   out/1M      ctx   realtime     batch
gpt-oss-20b                             0.017    0.085    65536       0.77      0.38
gemma-4-26b-a4b-it                       0.04     0.21    32768       1.85      0.93
qwen3-coder-30b                        0.0675     0.27    98304       2.70      1.35
qwen/qwen3-30b-a3b-instruct-2507     0.081267   0.2438    98304       2.84      1.42
qwen/qwen3-vl-30b-a3b-instruct           0.14     0.55    65536       5.55      2.77
meta/muse-glimmer-30b                    0.28      1.1   131072      11.10      5.55

Cleaned up, in USD per 1M tokens:

model	input	output	batch in / out	context	10k × (2k in + 500 out), realtime	same, batch
gpt-oss-20b	0.017	0.085	0.0085 / 0.0425	65,536	$0.77	$0.38
gemma-4-26b-a4b-it	0.04	0.21	0.02 / 0.105	32,768	$1.85	$0.93
qwen3-coder-30b	0.0675	0.27	0.03375 / 0.135	98,304	$2.70	$1.35
qwen3-30b-a3b-instruct-2507	0.0813	0.2438	0.0406 / 0.1219	98,304	$2.84	$1.42
qwen3-vl-30b-a3b-instruct	0.14	0.55	0.07 / 0.275	65,536	$5.55	$2.77
muse-glimmer-30b	0.28	1.10	0.14 / 0.55	131,072	$11.10	$5.55

The worked example is 10,000 requests with 2,000 input and 500 output tokens each, so 20M tokens in and 5M out. For gpt-oss-20b that is 20 × $0.017 + 5 × $0.085 = $0.34 + $0.425 = $0.765. Batch halves every line.

Two things stand out:

Output tokens weigh more than you'd think. Output costs 3–5× input on every model here. In this workload the 500 output tokens are a fifth of the tokens but about half of the bill.
Context is a hard limit, not a price. Gemma is cheap, but 32,768 tokens rules it out for long-document work no matter what it costs.

2. Same request, five models: where per-token prices lie

The table assumes every model writes 500 tokens. They don't. Here is one real support ticket classified by five of them, with each result priced from the live catalog:

# measure.py: send the same real request to each model and price what came back
import json, os, urllib.request
from openai import OpenAI

client = OpenAI(base_url="https://synap402.com/v1", api_key=os.environ["SYNAP_API_KEY"])
with urllib.request.urlopen("https://synap402.com/v1/models") as r:
    catalog = {m["id"]: m for m in json.load(r)["data"]}

TICKET = ("Hi, I was charged twice for my October invoice (#4471) and the second "
          "charge still hasn't been refunded. Can someone look at this today?")
PROMPT = ("Classify this support ticket. Answer with JSON only: "
          '{"category": "billing|bug|how-to|other", "urgent": true|false}\n\n' + TICKET)

for mid in ["gpt-oss-20b", "gemma-4-26b-a4b-it", "qwen3-coder-30b",
            "qwen/qwen3-30b-a3b-instruct-2507", "meta/muse-glimmer-30b"]:
    r = client.chat.completions.create(model=mid, max_tokens=400,
                                       messages=[{"role": "user", "content": PROMPT}])
    p, u = catalog[mid]["pricing"], r.usage
    cost = (u.prompt_tokens * p["prompt_per_million"] + u.completion_tokens * p["completion_per_million"]) / 1e6
    answer = (r.choices[0].message.content or "").strip().replace("\n", " ")
    print(f"{mid:34} {u.prompt_tokens:>4} in {u.completion_tokens:>4} out  ${cost:.7f}  {answer[:60]}")

gpt-oss-20b                         128 in  178 out  $0.0000173  {"category":"billing","urgent":true}
gemma-4-26b-a4b-it                   80 in   17 out  $0.0000068  ```

json {"category": "billing", "urgent": true}

qwen3-coder-30b 72 in 12 out $0.0000081 {"category": "billing", "urgent": true}
qwen/qwen3-30b-a3b-instruct-2507 72 in 12 out $0.0000088 {"category": "billing", "urgent": true}
meta/muse-glimmer-30b 117 in 199 out $0.0002517 {"category": "billing", "urgent": true}




All five got it right. Scaled to 10,000 tickets:

| model | per request | × 10,000 |
|---|---|---|
| gemma-4-26b-a4b-it | $0.0000068 | $0.07 |
| qwen3-coder-30b | $0.0000081 | $0.08 |
| qwen3-30b-a3b-instruct-2507 | $0.0000088 | $0.09 |
| gpt-oss-20b | $0.0000173 | $0.17 |
| muse-glimmer-30b | $0.0002517 | $2.52 |

**The cheapest model per token came fourth per request.** gpt-oss-20b is a reasoning model. It produced 178 output tokens, most of them thinking, to write a 36-character answer. Its chat template also turned the same prompt into 128 input tokens where Qwen counted 72. The two Qwen models answered in 12 tokens. For short, structured answers, a non-reasoning model at 3–4× the token price came out at under half the cost.

The opposite holds when the answer is long and the reasoning is what you pay for. Then gpt-oss-20b's $0.085 output price is hard to beat. Measure your own prompt. Don't rank models by the price column.

Also note Gemma wrapped its JSON in a Markdown fence. If you parse the output, use `response_format` (Gemma, gpt-oss and qwen3-coder accept `json_schema` here) and don't strip fences by hand.

## 3. Batch: the same job at half price

If nobody is waiting on the answer (nightly classification, evals, back-filling embeddings or summaries), send the requests as a batch. It's the standard OpenAI Batch API, so the official SDK works unchanged:



```python
# batch.py: the same job at half price through the OpenAI Batch API
import json, os, time
from openai import OpenAI

client = OpenAI(base_url="https://synap402.com/v1", api_key=os.environ["SYNAP_API_KEY"])
tickets = [
    "I was charged twice for invoice #4471, please refund the second charge.",
    "How do I rotate my API key without downtime?",
    "The export button returns a 500 error since this morning.",
]
with open("requests.jsonl", "w") as f:
    for i, t in enumerate(tickets):
        f.write(json.dumps({
            "custom_id": f"t{i}", "method": "POST", "url": "/v1/chat/completions",
            "body": {"model": "qwen3-coder-30b", "max_tokens": 50, "messages": [{"role": "user",
                     "content": 'Classify as JSON {"category": "billing|bug|how-to|other"}: ' + t}]},
        }) + "\n")

f = client.files.create(file=open("requests.jsonl", "rb"), purpose="batch")
b = client.batches.create(input_file_id=f.id, endpoint="/v1/chat/completions", completion_window="24h")
while b.status not in ("completed", "failed", "expired", "cancelled"):
    time.sleep(10)
    b = client.batches.retrieve(b.id)
print(b.status, b.request_counts)
for line in client.files.content(b.output_file_id).text.splitlines():
    r = json.loads(line)
    body = r["response"]["body"]
    print(r["custom_id"], body["usage"]["prompt_tokens"], body["usage"]["completion_tokens"],
          body["choices"][0]["message"]["content"].strip())

Output (the JSON fences in the answers are collapsed here for space):

completed BatchRequestCounts(completed=3, failed=0, total=3)
t0 44 14 {"category": "billing"}
t1 36 15 {"category": "how-to"}
t2 40 14 {"category": "bug"}

This small batch came back in about 15 seconds, but the contract is a 24-hour window, and live traffic goes first. Each line is billed when it completes, and a line that fails isn't billed. Batch is only available on the self-hosted models in the table. Other catalog models are refused when you create the batch.

Takeaways

Price the request, not the token. Run your real prompt once per candidate model and multiply. It takes ten lines (above).
Reasoning models are a per-request tax on short answers. Use them where the thinking is what you need.
Output tokens weigh more. Cap max_tokens, ask for JSON, and use structured outputs.
Anything that can wait a day costs half.
Read prices from the API, not from a blog post, this one included. /v1/models is the source, and the scripts above re-run in a second.

The same catalog also has larger models (GLM 5.3, DeepSeek V4, Qwen3.5 122B) for when a 30B model isn't enough. Their prices are on the pricing page.

Links: live price list at synap402.com/cheapest-llm-api · API docs · try models in the browser without signing up at synap402.com/chat. Keys start at $10, and top-ups don't expire. You can also pay per top-up in USDC on Base via x402, with no account.

Synap by Linkrra: one OpenAI-compatible API for open models. synap402.com

Running Qwen3 Coder 30B as a cheap subagent for Claude Code, Codex and opencode

Synap by Linkrra — Wed, 11 Nov 2026 16:20:13 +0000

Big frontier models are great at planning a change across a codebase. They are expensive overkill for "add type hints to this file", "fix the off-by-one in is_even" or "write two doctests". This post shows how to hand that second kind of work to Qwen3 Coder 30B (a 30B mixture-of-experts coding model with tool calling) through an OpenAI-compatible endpoint. It covers three agents, Claude Code, Codex CLI and opencode, plus a 40-line Python "subagent" you can call from any of them.

Everything below was run on 2026-11-11 against https://synap402.com/v1 (Synap, the API we build). The token counts and prices are copied from those runs.

The numbers first

From curl -s https://synap402.com/v1/models today:

model	input / 1M tokens	output / 1M tokens	batch (24h) in / out	context
`qwen3-coder-30b`	$0.0675	$0.27	$0.03375 / $0.135	98,304

It supports tools, tool_choice (auto, required), response_format with json_schema, and streaming.

There is also a free tier on this model: 100,000 tokens and 50 requests a day per account (Google sign-in, no card). It allows 10 requests a minute per key and 4,096 output tokens per answer. As you'll see below, one coding-agent task can use half of that, so it's for trying things out, not daily work.

1. Claude Code

Claude Code speaks Anthropic's Messages API, and the endpoint serves /v1/messages too. Five environment variables:

export ANTHROPIC_BASE_URL=https://synap402.com      # no /v1, Claude Code appends /v1/messages
export ANTHROPIC_AUTH_TOKEN=$SYNAP_API_KEY
export ANTHROPIC_MODEL=qwen3-coder-30b
export ANTHROPIC_DEFAULT_HAIKU_MODEL=qwen3-coder-30b  # its own background tasks
export CLAUDE_CODE_MAX_CONTEXT_TOKENS=98304          # otherwise it warns about an unknown model

I gave it a file with a deliberate bug:

# mathx.py
def add(a, b):
    return a - b

claude -p "mathx.py has a bug in add(). Fix it, then reply with one line saying what you changed." \
  --allowedTools "Read,Edit" --output-format json

Result on Claude Code 2.1.322: 6 turns, 11.3 seconds, "is_error": false, and the file now says return a + b. The model read the file, called Claude Code's own Edit tool and reported back. Claude Code also prints a costUSD estimate for a model it doesn't know. Ignore it and use the usage the API reports instead.

2. Codex CLI

Codex talks to the Responses API (/v1/responses). Add one provider block to ~/.codex/config.toml:

model_provider = "synap"
model = "qwen3-coder-30b"

[model_providers.synap]
name = "Synap"
base_url = "https://synap402.com/v1"
env_key = "SYNAP_API_KEY"
wire_api = "responses"

Then:

printf 'def is_even(n):\n    return n %% 2 == 1\n' > evens.py
codex exec --json --skip-git-repo-check -s workspace-write \
  "evens.py has a bug in is_even(). Fix it." </dev/null | grep turn.completed

On codex-cli 0.166.0 that printed:

{"type":"turn.completed","usage":{"input_tokens":49245,"cached_input_tokens":0,"output_tokens":722,"reasoning_output_tokens":0}}

and evens.py now returns n % 2 == 0. (Without </dev/null, codex exec sits waiting on stdin.)

Look at that input number: 49,245 tokens to fix one character. Almost all of it is Codex's system prompt and tool definitions, not your code. At $0.0675 per 1M input and $0.27 per 1M output:

49,245 × $0.0675 / 1M = $0.003324
   722 × $0.27   / 1M = $0.000195
                  total ≈ $0.0035 per task

So 200 small tasks like this a day comes to about $0.70. The same overhead is why one Codex task uses half the free daily allowance. Agent prompts are large, so per-input-token price matters much more than it does in chat.

3. opencode

opencode doesn't read /v1/models for a custom provider, so you list the model ids yourself. Put this in opencode.json in the project root. {env:...} keeps the key out of the file:

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "synap": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "Synap",
      "options": {
        "baseURL": "https://synap402.com/v1",
        "apiKey": "{env:SYNAP_API_KEY}"
      },
      "models": { "qwen3-coder-30b": { "name": "Qwen3 Coder 30B" } }
    }
  },
  "model": "synap/qwen3-coder-30b"
}

printf 'def square(x):\n    return x * 2\n' > sq.py
npx -y opencode-ai@latest run "sq.py: square() is wrong. Fix it." </dev/null

On opencode 1.19.5 it changed the function to x * x, then ran its own check over eight inputs (square(-3) = 9 …) before it answered. The first run is slow because opencode downloads the provider package then.

4. A real "subagent": keep your main model, delegate the chores

Running a whole session on a 30B model is fine for routine work. The more interesting setup is to keep your strong model as the planner and have it hand scoped edits to the small one. Every agent above can run a shell command, so the subagent can be a plain script:

# delegate.py: hand one scoped coding task to a small model, get JSON back, print the cost
import json, os, sys, urllib.request
from openai import OpenAI

BASE = "https://synap402.com/v1"
MODEL = "qwen3-coder-30b"
client = OpenAI(base_url=BASE, api_key=os.environ["SYNAP_API_KEY"])

def price(model_id):
    """Live USD per 1M tokens (input, output) from the public catalog."""
    with urllib.request.urlopen(f"{BASE}/models") as r:
        models = json.load(r)["data"]
    p = next(m for m in models if m["id"] == model_id)["pricing"]
    return p["prompt_per_million"], p["completion_per_million"]

def delegate(task, path):
    source = open(path).read()
    resp = client.chat.completions.create(
        model=MODEL,
        temperature=0.2,
        messages=[
            {"role": "system", "content": "You are a careful Python engineer. Change only what the task asks."},
            {"role": "user", "content": f"Task: {task}\n\nFile {path}:\n```

python\n{source}\n

```"},
        ],
        response_format={
            "type": "json_schema",
            "json_schema": {
                "name": "edit",
                "schema": {
                    "type": "object",
                    "properties": {
                        "summary": {"type": "string"},
                        "new_file": {"type": "string"},
                    },
                    "required": ["summary", "new_file"],
                },
            },
        },
    )
    out = json.loads(resp.choices[0].message.content)
    p_in, p_out = price(MODEL)
    u = resp.usage
    cost = u.prompt_tokens * p_in / 1e6 + u.completion_tokens * p_out / 1e6
    return out, u, cost

if __name__ == "__main__":
    out, u, cost = delegate(sys.argv[1], sys.argv[2])
    with open(sys.argv[2], "w") as f:
        f.write(out["new_file"])
    print(out["summary"])
    print(f"{u.prompt_tokens} in / {u.completion_tokens} out -> ${cost:.6f}")

Input file:

import re

def slugify(title):
    s = title.lower()
    s = re.sub(r"[^a-z0-9]+", "-", s)
    return s

pip install openai
python delegate.py "Strip leading/trailing dashes, add type hints and a docstring with two doctest examples." slugify.py
python -m doctest -v slugify.py

Output:

Added type hints, docstring with doctest examples, and modified the function to strip leading/trailing dashes as requested.
93 in / 202 out -> $0.000061
...
2 passed and 0 failed.

The edit runs without an agent harness, so there's no 49k-token system prompt: 93 tokens in, 202 out, six thousandths of a cent. The structured output means the caller gets a file it can write, not prose it has to parse. And the doctests the model wrote pass.

To wire it in, put one line in CLAUDE.md / AGENTS.md: "For single-file mechanical edits (type hints, docstrings, renames, small bug fixes, test scaffolds), run python delegate.py "<task>" <file> and review the diff instead of editing yourself."

When a 30B coder is enough, and when it isn't

From these runs and day-to-day use:

Good fit: single-file bug fixes, adding tests and doctests, type hints, docstrings, renames, boilerplate, turning a spec into a function, JSON-schema extraction from logs or tickets.
Keep the big model for: cross-file refactors where the plan matters more than typing, subtle concurrency or security reasoning, and anything that needs more than its 98,304-token context.
Always: run the tests. The small model is cheap enough that "generate, test, retry once" still costs less than one frontier call.

Try it

Guides with copy-paste config: Claude Code, Codex, opencode
Live price list: synap402.com/cheapest-llm-api
Try a model in the browser without signing up: synap402.com/chat

Paid keys start at $10, and top-ups don't expire. You can also pay in USDC through x402 with no account. Prompts and completions are not stored.

Synap by Linkrra: one OpenAI-compatible API for open models. synap402.com