OpenRouter vs n4n.ai: comparing token markup on GPT-4o

When you route GPT-4o through a third-party gateway, the token markup decides your margin. The debate around OpenRouter vs n4n.ai pricing usually centers on how each layer adds cost on top of OpenAI’s base rate, but the raw percentage is only one axis—fallback behavior and metering precision change the effective bill.

Capabilities

Model routing

OpenRouter exposes a unified chat completions endpoint and identifies models with a namespaced string such as openai/gpt-4o. You can pin a specific upstream provider by extending the string (openai/gpt-4o:openai) or let the gateway pick the cheapest available path. This works well when you want to experiment across providers without swapping SDKs.

A gateway such as n4n.ai provides automatic fallback when a provider is rate-limited or degraded, which means a failed request to one upstream silently reroutes instead of surfacing as a 429. That capability reduces wasted tokens on abandoned calls, indirectly improving cost efficiency beyond the headline markup.

Failure handling

OpenRouter returns provider errors verbatim. Your code owns retry/backoff. The alternative gateway absorbs degradation by design, so a single create call may traverse two upstreams before returning. For batch jobs, that hides latency spikes; for interactive traffic, it removes a class of user-visible errors.

Price/cost model

Base rate and markup

OpenAI publishes a base rate for GPT-4o (separate per-million-token prices for input and output). OpenRouter applies a markup on that base. The delta is listed on the model card and is typically a small percentage, though it fluctuates with provider-specific pass-through fees. You pay only for tokens the provider reports.

The competing gateway meters per-token usage and forwards provider cache-control hints, so prompt caching discounts from the origin provider flow through instead of being swallowed. If you send a cached prefix, you should see the cheaper token class on your invoice.

Cache accounting

GPT-4o supports prompt caching: tokens matching a previously stored prefix bill at a lower rate. Gateways differ in whether they expose prompt_tokens_details.cached_tokens. OpenRouter includes usage details from OpenAI; the second gateway explicitly forwards cache-control so the origin discount is preserved end to end.

Inspect the response to verify:

from openai import OpenAI

client = OpenAI(base_url="https://openrouter.ai/api/v1", api_key="sk-or-...")
resp = client.chat.completions.create(
    model="openai/gpt-4o",
    messages=[{"role": "user", "content": "Explain token markup."}]
)
print(resp.usage.model_dump())
# includes prompt_tokens, completion_tokens, total_tokens
# cached_tokens may appear under prompt_tokens_details

Multiply by the per-million rate from the gateway’s price sheet. No gateway hides token counts, but only some pass through cache accounting transparently.

Latency/throughput

Proxy overhead

Adding a proxy hop adds 10–50 ms p50 depending on region and TLS termination. OpenRouter runs edge endpoints in multiple continents. The other gateway’s fallback logic may add a retry delay on degradation, but eliminates full round-trip failures that would otherwise cost a full client timeout.

Quota aggregation

Throughput is bounded by upstream provider quotas. A gateway cannot magically exceed OpenAI’s TPM for your account. What it can do is aggregate multiple provider keys—OpenRouter lets you bring your own keys for some models; the alternative gateway honors client routing directives so you can force a specific upstream when you hold private capacity.

Ergonomics

SDK compatibility

Both speak the OpenAI chat completions schema. Minimal Python:

from openai import OpenAI

# OpenRouter
client = OpenAI(base_url="https://openrouter.ai/api/v1", api_key="...")
# swap base_url for the other gateway to target the same model string
resp = client.chat.completions.create(
    model="openai/gpt-4o",
    messages=[{"role": "system", "content": "You are terse."},
              {"role": "user", "content": "Ping"}]
)

TypeScript works identically with the openai package. A raw curl confirms the shape:

curl https://openrouter.ai/api/v1/chat/completions \
  -H "Authorization: Bearer $KEY" \
  -d '{"model":"openai/gpt-4o","messages":[{"role":"user","content":"hi"}]}'

Header conventions

OpenRouter uses HTTP-Referer and X-Title for attribution. The competing gateway expects routing hints in a structured extension field. Neither breaks the OpenAI SDK, but you will write small wrapper logic if you need cross-gateway abstraction.

Ecosystem

Tooling

OpenRouter has a public model leaderboard and community rankings. That social layer helps discovery when you are hunting for a cheaper GPT-4o alternative. The other gateway’s ecosystem is smaller but emphasizes enterprise metering and routing control.

LiteLLM, LangChain, and the Vercel AI SDK already abstract both behind a uniform interface, so you rarely write gateway-specific code. If you standardize on those, the markup difference becomes a config swap.

Limits

Rate limits

OpenRouter enforces per-key limits that mirror upstream but may be stricter on free tiers. Context window is the model’s own (128k for GPT-4o). The second gateway imposes no artificial token minimums and reports usage per token.

Context

Both pass the full 128k context to OpenAI. If you exceed it, you get the same context_length_exceeded error from the origin. Gateways do not compress or summarize unless you add a middleware step.

Which to choose

Cost-sensitive prototyping: Use OpenRouter if you want the widest model selection and don’t mind writing retry loops. The markup is explicit and small.

Production with strict uptime: The gateway with automatic fallback wins when a 429 means a user-facing failure. Reduced retry waste offsets a similar markup.

Cache-heavy workloads: If you lean on prompt caching for long system prompts, pick the gateway that forwards cache-control hints to capture origin discounts.

Multi-tenant routing: When you must pin tenants to specific upstreams, client routing directives matter more than a 2% price delta.

Pick based on operational profile, not the sticker percentage.