RelayPlane vs LiteLLM vs OpenRouter: an honest comparison for cost caps and routing

We need to reformat the article body into clean Markdown, preserving facts, not adding intro/outro. The article includes title and then article content. We must output only the reformatted article body, not the title. Also not wrap whole answer in a code fence. Use headings where topic shifts.

We need to break into paragraphs, add headings. Use bullet lists for enumerations. Use inline code or fenced code blocks for code/commands/identifiers.

We must preserve every fact, name, number, quotation exactly. Do not invent.

We need to handle repeated content (the article appears duplicated? It seems the article block includes repeated paragraphs. We need to preserve all content exactly as given, but we can restructure. However we must not remove any information. The duplicated content appears: first part before the table, then after the table there is repeated similar content. We must keep it all.

We need to ensure we don't add or remove any facts. So we need to include everything.

We'll produce sections: maybe "Overview", "What each one is", "Comparison table", "Where LiteLLM wins outright", "Where OpenRouter wins outright", "Where RelayPlane's narrow wedge is", "The honest answer", "Try it", "Source", "Top comments". Use headings.

We need to preserve the exact wording, but we can lightly polish for flow and grammar. However we must not change facts. We can adjust punctuation? The instruction: "Only restructure and lightly polish wording for flow and grammar; do not add an introduction, conclusion, opinion, or commentary of your own." So we can fix minor grammar but keep meaning.

We need to keep code snippets exactly: e.g., relayplane cap set --day 50, relayplane kill, relayplane resume, npm install -g @relayplane/proxy, etc.

We need to keep quotes exactly: e.g., "returns 429 budget_exceeded". Ensure we keep that.

We need to preserve the table as markdown? The article includes a table in plain text with pipes. We can keep it as a markdown table.

We need to ensure we don't add extra content not present. We'll just reformat.

Let's extract the article body (excluding title). The article starts after "Article:" line. We'll copy everything after that line until end.

Given the duplication, we need to include both occurrences.

Let's copy the article text exactly as given (excluding the title line). I'll copy from the prompt:

If you want a hard daily spend cap and a per-request cost ledger on one machine with no database server to run, RelayPlane is the smallest install of the three ( @relayplane/proxy on npm, free, MIT). If you want 100+ providers behind one gateway for a team, LiteLLM is the better tool. If you want a hosted API you don't run yourself, OpenRouter is the better tool. All three are real, none of them is a straight replacement for the other two, and this piece is an honest breakdown of where each one actually wins. I built RelayPlane, so I'm biased. Every RelayPlane line below matches its code or docs, and the LiteLLM and OpenRouter lines come from their own docs, linked under the table, so you can check them yourself. What each one is, in one line RelayPlane : a local proxy that meters every request on the machine it runs on, enforces a hard spend cap before the request leaves, and has a kill switch. No Docker, no Python, runs on localhost:4100 . LiteLLM : an open source AI gateway for a team, deployed as a service with virtual keys, per-tenant budgets, and 100+ providers behind one OpenAI-format API. OpenRouter : a hosted API that gives you one key and one endpoint for 500+ models across many providers, no infrastructure to run, billed through their platform. The comparison RelayPlane LiteLLM OpenRouter What it is Local proxy for one machine Self-hosted gateway for a team Hosted model marketplace Install npm install -g @relayplane/proxy pip install or uv , run the proxy No install, API key only Runs locally Yes Yes (self-hosted) No, cloud only Native providers 6 (Anthropic, OpenAI, Gemini, xAI, Ollama, and OpenRouter passthrough) 100+ 500+ (it IS the aggregator) Per-request cost ledger on your machine Yes, a local SQLite file, nothing to deploy Spend logs live in the proxy's database Dashboard on their cloud Hard daily spend cap enforced before the request leaves Yes ( relayplane cap set --day 50 , returns 429) Budgets per virtual key, team, user Per-key credit limits, enforced in their cloud Kill switch Yes, one command, survives a restart Block a virtual key via the admin API Disable the key in their dashboard Routing by task complexity Yes, one config field, hot reloads Router strategies you configure per deployment No, you pick the model per call Virtual keys / multi-tenant budgets No Yes, this is its core job Per-key limits, cloud side Self-hosted Yes Yes No Where your data lives Your machine only Wherever you deploy it Their servers License / model MIT, everything free MIT + enterprise license and hosted option Proprietary, 5.5% fee on credit purchases The LiteLLM column comes from github.com/BerriAI/litellm and docs.litellm.ai , the OpenRouter column from openrouter.ai/docs , and the RelayPlane column from github.com/RelayPlane/proxy and relayplane.com/docs . Where LiteLLM wins outright Provider breadth and the multi-tenant model. If you're running a platform team with multiple apps and want virtual keys, per-team budgets, load balancing across many deployments, and an admin dashboard for the whole org, that's what LiteLLM is built for. RelayPlane has none of that, it tracks one machine, not a tenant hierarchy. Where OpenRouter wins outright Zero infrastructure. You get an API key and you're calling 500+ models in one format, with nothing to run or maintain. The tradeoff is you don't get a local, offline-readable cost ledger or a hard cap enforced before the request leaves your machine, you're working from their dashboard and their usage API. Where RelayPlane's narrow wedge is Three things. I use all of them daily on a pipeline that routes real production traffic. A per-request ledger with no database server to run. Every request through localhost:4100 gets priced and written to a local SQLite file with model, tokens, cost, agent, and session. relayplane kills --last 7d shows every blocked request with the agent and session that caused it. A hard cap the proxy enforces, not a report you read after the bill arrives. relayplane cap set --day 50 returns 429 budget_exceeded on the request that would cross $50. Choose block, downgrade to a cheaper model, or warn. A kill switch that survives a restart. relayplane kill returns 503 kill_switch_active on every routed request until relayplane resume . You don't need a database server or an account for any of it. It's a single npm install. The honest answer to "which one should I use" Pick RelayPlane if you're solo or on one machine and want to see and cap what you're spending without standing up infrastructure. Pick LiteLLM if you run a platform team with several apps and users, and budgets that need enforcing per tenant. Pick OpenRouter if you don't want to run anything and just need one key for a lot of models. If you want OpenRouter's model catalog and a hard local cap, point RelayPlane at OpenRouter as its upstream. RelayPlane keeps the ledger and the kill switch, and OpenRouter supplies the models. Try it npm install -g @relayplane/proxy relayplane init relayplane start export ANTHROPIC_BASE_URL = http://localhost:4100 That's the whole setup. Source is at github.com/RelayPlane/proxy , MIT licensed, free, no paid tier.

If you want a hard daily spend cap and a per-request cost ledger on one machine with no database server to run, RelayPlane is the smallest install of the three (@relayplane/proxy on npm, free, MIT). If you want 100+ providers behind one gateway for a team, LiteLLM is the better tool. If you want a hosted API you don't run yourself, OpenRouter is the better tool. All three are real, none of them is a straight replacement for the other two, and this piece is an honest breakdown of where each one actually wins. I built RelayPlane, so I'm biased. Every RelayPlane line below matches its code or docs, and the LiteLLM and OpenRouter lines come from their own docs, linked under the table, so you can check them yourself. What each one is, in one line - RelayPlane: a local proxy that meters every request on the machine it runs on, enforces a hard spend cap before the request leaves, and has a kill switch. No Docker, no Python, runs on localhost:4100 . - LiteLLM: an open source AI gateway for a team, deployed as a service with virtual keys, per-tenant budgets, and 100+ providers behind one OpenAI-format API. - OpenRouter: a hosted API that gives you one key and one endpoint for 500+ models across many providers, no infrastructure to run, billed through their platform. The comparison | RelayPlane | LiteLLM | OpenRouter | | |---|---|---|---| | What it is | Local proxy for one machine | Self-hosted gateway for a team | Hosted model marketplace | | Install | npm install -g @relayplane/proxy | pip install or uv , run the proxy | No install, API key only | | Runs locally | Yes | Yes (self-hosted) | No, cloud only | | Native providers | 6 (Anthropic, OpenAI, Gemini, xAI, Ollama, and OpenRouter passthrough) | 100+ | 500+ (it IS the aggregator) | | Per-request cost ledger on your machine | Yes, a local SQLite file, nothing to deploy | Spend logs live in the proxy's database | Dashboard on their cloud | | Hard daily spend cap enforced before the request leaves | Yes (relayplane cap set --day 50 , returns 429) | Budgets per virtual key, team, user | Per-key credit limits, enforced in their cloud | | Kill switch | Yes, one command, survives a restart | Block a virtual key via the admin API | Disable the key in their dashboard | | Routing by task complexity | Yes, one config field, hot reloads | Router strategies you configure per deployment | No, you pick the model per call | | Virtual keys / multi-tenant budgets | No | Yes, this is its core job | Per-key limits, cloud side | | Self-hosted | Yes | Yes | No | | Where your data lives | Your machine only | Wherever you deploy it | Their servers | | License / model | MIT, everything free | MIT + enterprise license and hosted option | Proprietary, 5.5% fee on credit purchases | The LiteLLM column comes from github.com/BerriAI/litellm and docs.litellm.ai, the OpenRouter column from openrouter.ai/docs, and the RelayPlane column from github.com/RelayPlane/proxy and relayplane.com/docs. Where LiteLLM wins outright Provider breadth and the multi-tenant model. If you're running a platform team with multiple apps and want virtual keys, per-team budgets, load balancing across many deployments, and an admin dashboard for the whole org, that's what LiteLLM is built for. RelayPlane has none of that, it tracks one machine, not a tenant hierarchy. Where OpenRouter wins outright Zero infrastructure. You get an API key and you're calling 500+ models in one format, with nothing to run or maintain. The tradeoff is you don't get a local, offline-readable cost ledger or a hard cap enforced before the request leaves your machine, you're working from their dashboard and their usage API. Where RelayPlane's narrow wedge is Three things. I use all of them daily on a pipeline that routes real production traffic. - A per-request ledger with no database server to run. Every request through localhost:4100 gets priced and written to a local SQLite file with model, tokens, cost, agent, and session.relayplane kills --last 7d shows every blocked request with the agent and session that caused it. - A hard cap the proxy enforces, not a report you read after the bill arrives. relayplane cap set --day 50 returns429 budget_exceeded on the request that would cross $50. Choose block, downgrade to a cheaper model, or warn. - A kill switch that survives a restart. relayplane kill returns503 kill_switch_active on every routed request untilrelayplane resume . You don't need a database server or an account for any of it. It's a single npm install. The honest answer to "which one should I use" - Pick RelayPlane if you're solo or on one machine and want to see and cap what you're spending without standing up infrastructure. - Pick LiteLLM if you run a platform team with several apps and users, and budgets that need enforing per tenant. - Pick OpenRouter if you don't want to run anything and just need one key for a lot of models. - If you want OpenRouter's model catalog and a hard local cap, point RelayPlane at OpenRouter as its upstream. RelayPlane keeps the ledger and the kill switch, and OpenRouter supplies the models. Try it npm install -g @relayplane/proxy relayplane init relayplane start export ANTHROPIC_BASE_URL=http://localhost:4100 That's the whole setup. Source is at github.com/RelayPlane/proxy, MIT licensed, free, no paid tier. Top comments (1) The deployment boundary is the real differentiator here. A local ledger plus a preflight cap makes spend control auditable before a request leaves the machine, while LiteLLM still fits teams that need tenant budgets. The OpenRouter plus local cap combination is a useful middle path for teams that want breadth without giving up guardrails.

We need to preserve exactly. However there are some minor formatting differences: spaces, punctuation. We'll keep as is but we can lightly polish for grammar (like fixing missing spaces). But we must be careful not to change facts. Changing spacing is okay.

We'll produce markdown with headings.

Let's structure:

Overview

Then the first paragraph(s) up to "What each one is, in one line". Then maybe a subsection "What each one is" with bullet list.

Then "Comparison" with the table.

Then "Where LiteLLM wins outright"

Then "Where OpenRouter wins outright"

Then "Where RelayPlane's narrow wedge is"

Then "The honest answer to 'which one should I use'"

Then "Try it"

Then "Source"

Then "Top comments"

We need to keep the duplicated content: The first block before the table and after the table includes similar content; we need to include both. However the second block after the table repeats much of the same content but with some variations (like bullet points with dashes). We must include all.

Thus after the table we will include the second block exactly as given (maybe as a paragraph). We'll keep it.

Let's craft.

We need to ensure we don't omit any sentences. Let's copy the first block (before the table) and second block (after the table) as they appear.

First block (before table) text:

If you want a hard daily spend cap and a per-request cost ledger on one machine with no database server to run, RelayPlane is the smallest install of the three ( @relayplane/proxy on npm, free, MIT). If you want 100+ providers behind one gateway for a team, LiteLLM is the better tool. If you want a hosted API you don't run yourself, OpenRouter is the better tool. All three are real, none of them is a straight replacement for the other two, and this piece is an honest breakdown of where each one actually wins. I built RelayPlane, so I'm biased. Every RelayPlane line below matches its code or docs, and the LiteLLM and OpenRouter lines come from their own docs, linked under the table, so you can check them yourself. What each one is, in one line RelayPlane : a local proxy that meters every request on the machine it runs on, enforces a hard spend cap before the request leaves, and has a kill switch. No Docker, no Python, runs on localhost:4100 . LiteLLM : an open source AI gateway for a team, deployed as a service with virtual keys, per-tenant budgets, and 100+ providers behind one OpenAI-format API. OpenRouter : a hosted API that gives you one key and one endpoint for 500+ models across many providers, no infrastructure to run, billed through their platform.

Note there is a space before the parentheses in first sentence: "( @relayplane/proxy". We'll keep.

Second block (after table) text:

If you want a hard daily spend cap and a per-request cost ledger on one machine with no database server to run, RelayPlane is the smallest install of the three (@relayplane/proxy on npm, free, MIT). If you want 100+ providers behind one gateway for a team, LiteLLM is the better tool. If you want a hosted API you don't run yourself, OpenRouter is the better tool. All three are real, none of them is a straight replacement for the other two, and this piece is an honest breakdown of where each one actually wins. I built RelayPlane, so I'm biased. Every RelayPlane line below matches its code or docs, and the LiteLLM and OpenRouter lines come from their own docs, linked under the table, so you can check them yourself. What each one is, in one line - RelayPlane: a local proxy that meters every request on the machine it runs on, enforces a hard spend cap before the request leaves, and has a kill switch. No Docker, no Python, runs on localhost:4100 . - LiteLLM: an open source AI gateway for a team, deployed as a service with virtual keys, per-tenant budgets, and 100+ providers behind one OpenAI-format API. - OpenRouter: a hosted API that gives you one key and one endpoint for 500+ models across many providers, no infrastructure to run, billed through their platform.

Note differences: parentheses without space, bullet list with dashes.

We'll keep both.

Now the table: we need to include exactly as given:

The comparison | RelayPlane | LiteLLM | OpenRouter | | |---|---|---|---| | What it is | Local proxy for one machine | Self-hosted gateway for a team | Hosted model marketplace | | Install | npm install -g @relayplane/proxy | pip install or uv , run the proxy | No install, API key only | | Runs locally | Yes | Yes (self-hosted) | No, cloud only | | Native providers | 6 (Anthropic, OpenAI, Gemini, xAI, Ollama, and OpenRouter passthrough) | 100+ | 500+ (it IS the aggregator) | | Per-request cost ledger on your machine | Yes, a local SQLite file, nothing to deploy | Spend logs live in the proxy's database | Dashboard on their cloud | | Hard daily spend cap enforced before the request leaves | Yes (relayplane cap set --day 50 , returns 429) | Budgets per virtual key, team, user | Per-key credit limits, enforced in their cloud | | Kill switch | Yes, one command, survives a restart | Block a virtual key via the admin API | Disable the key in their dashboard | | Routing by task complexity | Yes, one config field, hot reloads | Router strategies you configure per deployment | No, you pick the model per call | | Virtual keys / multi-tenant budgets | No | Yes, this is its core job | Per-key limits, cloud side | | Self-hosted | Yes | Yes | No | | Where your data lives | Your machine only | Wherever you deploy it | Their servers | | License / model | MIT, everything free | MIT + enterprise license and hosted option | Proprietary, 5.5% fee on credit purchases |

Note there is an extra leading pipe after "The comparison". We'll keep as is.

After table, there is a sentence: "The LiteLLM column comes from github.com/BerriAI/litellm and docs.litellm.ai , the OpenRouter column from openrouter.ai/docs , and the RelayPlane column from github.com/RelayPlane/proxy and relayplane.com/docs ."

We need to include that.

Then the sections: "Where LiteLLM wins outright", etc.

We need to preserve the exact wording, including punctuation.

Let's copy the sections exactly as they appear after that sentence in the first block.

From first block after the table sentence:

Where LiteLLM wins outright Provider breadth and the multi-tenant model. If you're running a platform team with multiple apps and want virtual keys, per-team budgets, load balancing across many deployments, and an admin dashboard for the whole org, that's what LiteLLM is built for. RelayPlane has none of that, it tracks one machine, not a tenant hierarchy. Where OpenRouter wins outright Zero infrastructure. You get an API key and you're calling 500+ models in one format, with nothing to run or maintain. The tradeoff is you don't get a local, offline-readable cost ledger or a hard cap enforced before the request leaves your machine, you're working from their dashboard and their usage API. Where RelayPlane's narrow wedge is Three things. I use all of them daily on a pipeline that routes real production traffic. A per-request ledger with no database server to run. Every request through localhost:4100 gets priced and written to a local SQLite file with model, tokens, cost, agent, and session. relayplane kills --last 7d shows every blocked request with the agent and session that caused it. A hard cap the proxy enforces, not a report you read after the bill arrives. relayplane cap set --day 50 returns 429 budget_exceeded on the request that would cross $50. Choose block, downgrade to a cheaper model, or warn. A kill switch that survives a restart. relayplane kill returns 503 kill_switch_active on every routed request until relayplane resume . You don't need a database server or an account for any of it. It's a single npm install. The honest answer to "which one should I use" Pick RelayPlane if you're solo or on one machine and want to see and cap what you're spending without standing up infrastructure. Pick LiteLLM if you run a platform team with several apps and users, and budgets that need enforcing per tenant. Pick OpenRouter if you don't want to run anything and just need one key for a lot of models. If you want OpenRouter's model catalog and a hard local cap, point RelayPlane at OpenRouter as its upstream. RelayPlane keeps the ledger and the kill switch, and OpenRouter supplies the models. Try it npm install -g @relayplane/proxy relayplane init relayplane start export ANTHROPIC_BASE_URL = http://localhost:4100 That's the whole setup. Source is at github.com/RelayPlane/proxy , MIT licensed, free, no paid tier.

Now after that, the second block repeats similar content but with some differences: bullet points, slight variations.

We need to include the second block after its table sentence as well.

From second block after its table sentence:

The LiteLLM column comes from github.com/BerriAI/litellm and docs.litellm.ai, the OpenRouter column from openrouter.ai/docs, and the RelayPlane column from github.com/RelayPlane/proxy and relayplane.com/docs. Where LiteLLM wins outright Provider breadth and the multi-tenant model. If you're running a platform team with multiple apps and want virtual keys, per-team budgets, load balancing across many deployments, and an admin dashboard for the whole org, that's what LiteLLM is built for. RelayPlane has none of that, it tracks one machine, not a tenant hierarchy. Where OpenRouter wins outright Zero infrastructure. You get an API key and you're calling 500+ models in one format, with nothing to run or maintain. The tradeoff is you don't get a local, offline-readable cost ledger or a hard cap enforced before the request leaves your machine, you're working from their dashboard and their usage API. Where RelayPlane's narrow wedge is Three things. I use all of them daily on a pipeline that routes real production traffic. - A per-request ledger with no database server to run. Every request through localhost:4100 gets priced and written to a local SQLite file with model, tokens, cost, agent, and session.relayplane kills --last 7d shows every blocked request with the agent and session that caused it. - A hard cap the proxy enforces, not a report you read after the bill arrives. relayplane cap set --day 50 returns429 budget_exceeded on the request that would cross $50. Choose block, downgrade to a cheaper model, or warn. - A kill switch that survives a restart. relayplane kill returns503 kill_switch_active on every routed request untilrelayplane resume . You don't need a database server or an account for any of it. It's a single npm install. The honest answer to "which one should I use" - Pick RelayPlane if you're solo or on one machine and want to see and cap what you're spending without standing up infrastructure. - Pick LiteLLM if you run a platform team with several apps and users, and budgets that need enforing per tenant. - Pick OpenRouter if you don't want to run anything and just need one key for a lot of models. - If you want OpenRouter's model catalog and a hard local cap, point RelayPlane at OpenRouter as its upstream. RelayPlane keeps the ledger and the kill switch, and OpenRouter supplies the models. Try it npm install -g @relayplane/proxy relayplane init relayplane start export ANTHROPIC_BASE_URL=http://localhost:4100 That's the whole setup. Source is at github.com/RelayPlane/proxy, MIT licensed, free, no paid tier. Top comments (1) The deployment boundary is the real differentiator here. A local ledger plus a preflight cap makes spend control auditable before a request leaves the machine, while LiteLLM still fits teams that need tenant budgets. The OpenRouter plus local cap combination is a useful middle path for teams that want breadth without giving up guardrails.

Note there are some typos: "enforing" missing 'c', "returns429" missing space, "untilrelayplane" missing space. We must preserve exactly.

Thus we need to include both blocks.

Now we need to format with headings.

We'll produce:

Overview

Then the first paragraph(s) up to "What each one is, in one line". Actually we can combine the first two paragraphs (the repeated intro) as overview.

But we need to keep the exact text; we can split into paragraphs.

Let's produce:

Overview (maybe not needed as heading but we can use ## Overview). The instruction: "Add Markdown section headings (## Heading) where the topic clearly shifts". So we can add headings for each major section.

We'll have:

Overview

Then the first block (the introductory paragraphs) up to before "What each one is,