RelayPlane is an npm-native Node.js LLM proxy. Install with npm install @relayplane/proxy, point your ANTHROPIC_BASE_URL or OPENAI_BASE_URL at http://localhost:4100, and get per-request cost tracking, complexity-based model routing, and Ollama local fallback — no Docker required.

How does RelayPlane compare to LiteLLM?

LiteLLM is a Python library with a proxy server option. RelayPlane is npm-native for Node.js developers — no Python, no Docker, just npm install. RelayPlane has per-request cost tracking built in and integrates directly with Claude Code, Cursor, and OpenClaw via a simple base URL override.

How does RelayPlane compare to Portkey or Helicone?

Portkey and Helicone offer cloud observability and are npm-compatible. RelayPlane runs entirely locally (no cloud required), is open source under MIT, and focuses on cost tracking plus complexity-based routing for Node.js developers using Claude Code, Cursor, and OpenClaw.

Does RelayPlane work with Claude Code and Cursor?

Yes. RelayPlane is designed for Claude Code, Cursor, and any tool that supports ANTHROPIC_BASE_URL or OPENAI_BASE_URL. Set ANTHROPIC_BASE_URL=http://localhost:4100 and RelayPlane intercepts every request, tracks costs, and routes to cheaper models for simple tasks.

Yes. RelayPlane is open source (MIT license) and free to self-host. All features work locally with no account required. There are no paid tiers currently.

How do I install the RelayPlane npm LLM proxy?

Run: npm install -g @relayplane/proxy. Then: relayplane init && relayplane start. The local dashboard runs at http://localhost:4100. Set ANTHROPIC_BASE_URL=http://localhost:4100 in your environment and all Claude requests route through RelayPlane automatically.

relayplanellm-gatewaycomparisonopenroutercloudflarelitellm

LLM Gateway Comparison 2026: OpenRouter, Cloudflare, LiteLLM, and RelayPlane

Name: RelayPlane
Author: Matt Turley

Matt Turley·March 12, 2026·8 min read

The LLM gateway space has gotten crowded. OpenRouter, Cloudflare AI Gateway, LiteLLM, AWS Bedrock, and a handful of newer tools all want to sit between your application and your provider APIs. They are not the same thing. Some are routing services. Some are observability layers. Some are full control planes. Picking the wrong one means either rebuilding later or running infrastructure that does not fit your stack.

This comparison focuses on 2026 options and what each one actually delivers when you put it in production.

The Contenders

The gateways worth comparing right now are OpenRouter, Cloudflare AI Gateway, LiteLLM Proxy, and RelayPlane. Each has a different primary use case, and understanding that distinction is more useful than a feature checklist.

OpenRouter

OpenRouter is a hosted API aggregator. You get one API key and access to 200+ models from dozens of providers. The setup is genuinely zero-friction: point your OpenAI client at https://openrouter.ai/api/v1, use your OpenRouter key, and request any model by its full identifier. No infrastructure to run.

The tradeoff is that OpenRouter is a cloud middleman. Every request goes through their servers, so you are adding network latency and trusting their uptime. For prototyping and cross-provider model exploration, it is hard to beat. For production systems with compliance requirements or strict latency budgets, that dependency on an external routing service becomes a liability.

Cost tracking on OpenRouter is aggregate. You see what you spent through their dashboard, but you do not get per-request cost metadata back in your API responses. If you need to attribute costs to users, tenants, or specific workflows, you are building that layer yourself.

Cloudflare AI Gateway

Cloudflare AI Gateway is an observability and caching layer that runs at Cloudflare's edge. You route your provider calls through a Cloudflare URL, and you get logs, latency metrics, and the ability to cache responses. There is no routing logic, no provider failover, and no budget enforcement. It is a transparent proxy that records what passes through it.

If you are already on Cloudflare Workers and want request logging and semantic caching without standing up your own infrastructure, it fits naturally. For anything beyond observability, such as routing traffic between providers or enforcing spend limits, it does not apply.

LiteLLM Proxy

LiteLLM started as a Python SDK for normalizing LLM API calls and grew into a full proxy server. The coverage is exceptional: 100+ providers, virtual keys, team budgets, spend tracking via Postgres, and a management UI. It is the most feature-complete open-source option available.

The operational cost is real. Full LiteLLM with spend tracking requires Postgres and a Redis instance alongside the proxy itself. Docker Compose is the recommended setup. For a Python team that already runs containers and needs enterprise-level controls, that is a reasonable investment. For a Node.js team adding a Python service to their stack just to get a proxy, it adds friction at every step: deploy, debug, and upgrade.

RelayPlane

RelayPlane is an npm-installable LLM proxy built for Node.js environments. No Docker, no Postgres, no Python. The full install and startup is:

npm install -g @relayplane/proxy
relayplane init
relayplane start

That runs a proxy on localhost:4100 with per-request cost tracking, complexity-based routing across 11 providers, and budget enforcement baked in. The cost data comes back in the response metadata for every call, so you can attribute it to users, sessions, or workflows in your own code.

The Real Difference: Where They Live in Your Stack

The most useful framing is not features, it is where the gateway runs and who owns it.

OpenRouter and Cloudflare AI Gateway are cloud-hosted. You do not run them; you route through them. That makes them fast to set up and zero infrastructure to maintain. The tradeoff is that your LLM traffic passes through a third-party service, which is a compliance concern for some teams and a latency variable for everyone.

LiteLLM and RelayPlane run locally or self-hosted. Your requests never leave your infrastructure unless you want them to. LiteLLM requires more infrastructure to run but supports more providers. RelayPlane requires less infrastructure and is built specifically for Node.js teams.

Cost Tracking: What "Per-Request" Actually Means

All four tools surface cost data in different ways, and the difference matters when you are building a multi-tenant product or trying to debug a cost spike.

OpenRouter gives you cost data in each response under usage.cost. That is genuinely useful and is one of the better implementations in this category. The cost is calculated on their side using their pricing data, which means you trust their numbers and cannot audit the formula.

Cloudflare AI Gateway logs requests but does not return cost metadata to the caller. You go to their dashboard to look at aggregate spend. There is no way to surface that data per-request in your application.

LiteLLM tracks spend in Postgres, queryable via their API. This is comprehensive but requires that database to be running and the proxy to be configured with team and user identifiers. The setup works well once it is running; getting there takes time.

RelayPlane returns cost metadata in every response object. Input tokens, output tokens, model price, and computed cost are available without any database or external service. Anthropic prompt cache read savings and write costs are tracked separately, which matters when running Claude at scale because those two cost lines are different rates and can be significant.

Provider Routing and Failover

If one of your providers goes down or rate-limits you, what happens?

OpenRouter handles this automatically. They route around provider outages and retry on your behalf. You do not see the mechanics; the request either succeeds or fails after their retry logic runs out. For teams that want reliability without configuring it themselves, this is one of OpenRouter's strongest features.

Cloudflare AI Gateway does not route or failover. If the provider returns an error, the error reaches your application.

LiteLLM supports fallback configurations where you define a priority list of models. If the primary model fails, the proxy tries the next one. The configuration is explicit and documented.

RelayPlane routes requests based on complexity. You configure which models handle simple versus complex tasks, and the proxy routes accordingly. Cascade fallback, where a failed request retries on a cheaper or different model, is part of the routing config. The logic is in your config file, not hidden in a cloud service.

Which One to Choose

Prototyping across many models with zero setup: OpenRouter. The model catalog is unmatched and you are running in two minutes.

Cloudflare-native stack needing request logging: Cloudflare AI Gateway. Fits naturally, costs nothing extra if you are already using Workers.

Python team needing full enterprise controls: LiteLLM. Accept the infrastructure overhead; the feature set justifies it for large teams.

Node.js team that wants cost intelligence locally: RelayPlane. Installs from npm, runs in seconds, returns cost data per request, enforces budgets without a database. The right fit for Node.js shops that do not want Python infrastructure.

npm install @relayplane/proxy

One command. The proxy handles the rest.

RelayPlane is open source: github.com/RelayPlane/proxy. Package: @relayplane/proxy on npm. Supports 11 providers. Last verified: 2026-03-12.

All posts