Lynkr vs LiteLLM vs OpenRouter vs PortKey: Choosing an LLM Gateway in 2026

If you're building anything on top of LLMs in 2026 — a chatbot, an agent, a coding tool, an internal AI app — you've probably hit the same wall I did:

• One provider goes down and your product dies with it.
• Your OpenAI bill is climbing faster than your MRR.
• You want to try a cheaper model, but switching means rewriting code.
• Your team is now juggling 4 different SDKs for 4 different providers.

The answer is an LLM gateway — a proxy that sits between your app and every LLM provider, giving you one API, automatic failover, cost routing, and observability.

There are four serious contenders in this space right now: Lynkr, LiteLLM, OpenRouter, and PortKey. I've shipped production code on all four. Here's an honest comparison.

Full disclosure: I built Lynkr. I'll try to be fair about where the others are stronger.

---

TL;DR

	Lynkr	LiteLLM	OpenRouter	PortKey
Setup	npm install -g lynkr (3 lines)	Python + Docker + Postgres	Account signup, no self-host	Docker + YAML config
Self-hosted	✅	✅	❌ (SaaS only)	✅ (paid tier)
Claude Code / Codex / Cursor native	✅	⚠️ (manual config)	❌	⚠️ (manual config)
Local models (Ollama, llama.cpp)	✅ first-class	⚠️ Ollama only	❌	❌
Token optimization (caching/dedup)	✅ Built-in (60-80%)	❌	⚠️ Provider caching only	✅ Caching layer
Auto-failover	✅	✅	✅	✅
Observability dashboard	Basic	✅ Strong	✅ Strong	✅ Strongest
License	Apache 2.0	MIT	Proprietary	Mixed (OSS + paid)
Best for	Devs who want zero-config + coding tools	Python teams w/ existing infra	Quick prototyping	Enterprise observability

---

1. Lynkr — Zero-config gateway with first-class coding-tool support

What it is: A self-hosted Node.js proxy that exposes both OpenAI and Anthropic wire protocols, routing to 12+ providers underneath.

Where it wins:

• Drop-in for Claude Code, Codex CLI, and Cursor. Set one env var (ANTHROPIC_BASE_URL=http://localhost:8081) and your existing tools transparently use any backend — Ollama, Bedrock, OpenRouter, Azure, DeepSeek. No other gateway in this list speaks the Anthropic protocol natively, which means none of them work as drop-ins for Claude Code.
• Built-in token optimization (smart tool selection, prompt caching, memory dedup) shaves 60-80% off token counts on top of provider savings.
• 3-command install:

   npm install -g lynkr
   export ANTHROPIC_BASE_URL=http://localhost:8081
   lynkr start

• Local-first. Ollama, llama.cpp, LM Studio, MLX are all first-class providers, not afterthoughts. Run Claude Code on free local models.
• Apache 2.0, self-hosted, your data never leaves your infra.

Where it loses:

• Observability is basic — log-level only. If you need a polished dashboard with per-team usage charts, PortKey or LiteLLM are ahead.
• Newer project, smaller community than LiteLLM (~700 tests passing, growing).
• Node.js only — if your team is Python-first, the LiteLLM SDK feels more native.

Pick Lynkr if: You want a coding-tool gateway that works in 60 seconds, or you want to run local models with the tools you already use.

🔗 https://github.com/Fast-Editor/Lynkr

---

2. LiteLLM — The mature Python-native gateway

What it is: The granddaddy of LLM gateways. A Python library and proxy server that normalizes 100+ providers to the OpenAI API format.

Where it wins:

• Massive provider coverage. Hands down the most LLM providers supported — every obscure model you can name.
• Strong Python SDK. If your app is Python, from litellm import completion feels native.
• Enterprise features: team management, budgets, virtual keys, SSO, audit logs.
• Mature dashboard (LiteLLM UI) with per-key spend tracking.
• Battle-tested — used by Microsoft, Anthropic internal teams, and tons of YC startups.

Where it loses:

• Setup is heavy. Production deployment wants Docker + Postgres + Redis. Not a "3 commands and go" experience.
• No Anthropic protocol support. Can't drop into Claude Code as a transparent backend.
• No token optimization layer. You pay full token cost.
• Local model support is shallow — Ollama works, but llama.cpp/MLX are second-class.

Pick LiteLLM if: You have a Python codebase, need enterprise features (teams, budgets, SSO), and you're comfortable running Postgres.

---

3. OpenRouter — Quick prototyping, zero self-hosting

What it is: A hosted SaaS that aggregates 100+ models behind one OpenAI-compatible API. You pay them, they pay the providers.

Where it wins:

• Literally zero setup. Sign up, get an API key, change your base URL. Done in 60 seconds.
• Single bill instead of managing 5 provider accounts.
• Built-in fallback — if one model fails, route to another automatically.
• Auto-discovery of new models — they add them as providers release them.
• Great for prototyping when you want to A/B test models without commitment.

Where it loses:

• Not self-hosted. Your prompts and completions transit their infrastructure. For many enterprises, that's a non-starter.
• No local model support. Cloud-only by design.
• No Anthropic protocol — doesn't work with Claude Code, Cursor, or anything that expects Anthropic's API shape.
• Markup on tokens. They take a small margin on every API call (~5%).
• No token optimization. You pay full token cost, plus their margin.

Pick OpenRouter if: You're prototyping, you don't care about self-hosting, and you want the simplest possible "try any model" experience.

---

4. PortKey — Enterprise observability + gateway

What it is: A gateway + observability platform that emphasizes prompt management, evals, and production monitoring.

Where it wins:

• Best-in-class observability. Per-request tracing, prompt versioning, eval pipelines, latency/cost dashboards.
• Prompt management built in. Treat prompts like code with versions, A/B tests, and rollback.
• Caching layer — semantic + exact-match caching out of the box.
• Guardrails — built-in PII filtering, content moderation, response validation.
• SOC 2, HIPAA options for regulated industries.

Where it loses:

• Configuration is heavy. YAML-driven, with a learning curve. Not for weekend hacking.
• The good stuff is paid. Self-hosted is free, but team features and advanced observability require their cloud or enterprise tier.
• Coding-tool integration is manual — no native drop-in for Claude Code or Codex.
• Doesn't shine for local models.

Pick PortKey if: You're an enterprise that needs deep observability, governance, and prompt management more than you need raw provider count.

---

How to choose — by use case

"I want to run Claude Code on free local models"

→ Lynkr. It's the only one in this list that natively speaks Anthropic's protocol, which is what Claude Code expects. Three commands and you're running Claude Code on Ollama for $0/day.

"I'm prototyping and just want to try every model fast"

→ OpenRouter. Sign up, swap base URL, done. Don't self-host until you have to.

"I have a Python production codebase with team budgets and SSO needs"

→ LiteLLM. Mature, Python-native, every enterprise feature.

"I need deep observability, prompt versioning, and compliance"

→ PortKey. Most polished dashboards and governance features.

"I'm building a multi-provider product and want token costs minimized"

→ Lynkr (for the built-in 60-80% optimization) or LiteLLM (for breadth).

---

The honest landscape in 2026

LLM gateways used to be a "nice to have." In 2026 they're table stakes — provider outages, pricing changes, and the explosion of capable open models mean no serious app should be hard-wired to one provider.

The right gateway depends on what you're building:

• Coding tools and local-model fans: Lynkr.
• Python production apps with team management: LiteLLM.
• Quick prototyping with zero ops: OpenRouter.
• Regulated enterprise with deep observability: PortKey.

The good news: all four are viable. The bad news: most teams pick the wrong one because they didn't realize the others existed.

If you're paying any LLM bill today, the highest-leverage hour you can spend this week is switching to a gateway. Pick one, point your app at it, and never let a provider outage take you down again.

---

What gateway are you running, and what do you wish it did better? Drop a comment — I'd love to see what's working and what isn't.