Langfuse alternative: observability AND routing AND governance included on every plan

The answer in one line: Langfuse traces the calls your code already made; it does not decide which model made them. Keep tracing and routing in separate layers and you still own four surfaces yourself — per-provider auth and key rotation, the fallback chain, guardrails, and per-team budget enforcement. Collapsing them into one gateway pays off when surface count is your problem, and is the wrong trade when an open-source self-host is non-negotiable. Both cases are drawn below, axis by axis.

If you typed "Langfuse alternative" into Google, you're probably one of three readers:

1. You run Langfuse Cloud (Hobby or Pro) for tracing, prompt management, and evals on top of your LLM calls — and you pay separately for whatever routes those calls to the model in the first place (an LLM gateway, a homegrown provider abstraction, or direct provider SDKs).^{1 2} You want to know if one tool can collapse routing + observability + governance into one surface instead of paying two invoices and integrating two SDKs.
2. You self-host Langfuse (the open-source release or the EE add-ons) because your security or compliance posture rules out a hosted observability vendor — and you're now asking whether there's a complementary gateway that ships every governance primitive on day one so you don't end up writing your own guardrails, A/B testing, and per-team budget layer next to a Langfuse self-host.^{3 2}
3. You're evaluating Langfuse greenfield because the "open-source LLM observability + prompt management + evals" pitch resonates, but you also want to know what you're not getting in one product — what routing, fallback, multi-provider auth, guardrails, and per-team budget surfaces Langfuse delegates back to the rest of your stack — before committing your LLM observability to a specialist layer.^{1 2}

All three are honest concerns. Langfuse is a real product with a credible thesis — own LLM observability + prompt management + evals + datasets as a focused specialist layer, ship an open-source self-host AND a hosted Cloud tier, and let the operator pick whichever fits their compliance and operational posture.^{1 3} For a team whose primary need is "the observability and prompt-management layer is the lever, the rest of our LLM stack is fine," Langfuse's specialist focus is a defensible answer.

This post isn't an attack on Langfuse — it's an honest answer to the search: what does nRouter do differently when your team wants observability AND routing AND governance live in one gateway, on day one, free on every tier, and is the switch (or the alternative pick at greenfield) worth your afternoon?

The short version: every nRouter customer, on every tier, from day one, gets the full LLM governance surface — guardrails, A/B tests, prompt management, evals, per-team budgets — for free, and routes to the models available in your live catalog behind one API key.⁴ Plans vary the platform fee — 4% of the credits on pay-as-you-go, 0% on Pro — not the feature set.^{4 5}

This post is the head-to-head: axis by axis, with citations, and an honest section on when Langfuse is genuinely the right call.

---

Side-by-side at a glance

Every "Included free" claim on the nRouter column is real on every tier — guardrails, A/B tests, prompt management, prompt recommendations, and per-team budgets, all isolated per tenant, all available to every customer, no feature flags.⁴ Langfuse's column defers to their published docs and pricing pages on every per-plan or per-capability gating row — Langfuse's product surface ships on their own release cadence (per-plan feature changes, OSS vs EE splits, supported-framework expansions), so any specific dollar number or per-plan feature-gating row quoted here would risk staleness.^{1 2 3}

The pattern: Langfuse is a specialist observability + prompt-management + evals layer with an OSS self-host option and a hosted Cloud tier — its primary product surface is the observability + prompt + eval primitives themselves, and the routing + multi-provider auth + fallback + guardrails + virtual-key + per-team-budget surfaces are delegated to whichever gateway you run in front of Langfuse. nRouter is a full LLM gateway that bundles routing + observability + governance into one cloud-hosted product where every governance + observability primitive is free on every tier and the only thing the plan varies is the platform fee on credit purchases (4% of the credits on pay-as-you-go, 0% on Pro) and the RPM / TPM caps. The boundary lives at "is observability the buying motion, or is the buying motion an LLM gateway that already comes with observability."^{4 1 2}

Langfuse is a trademark of its owner. nRouter is not affiliated with or endorsed by Langfuse. All Langfuse claims above defer to Langfuse's own published pricing, docs, and GitHub pages on the date stamped in the footnotes; if any have changed, email hello@nrouter.ai and we'll re-audit.

---

Pricing tiers explained

The table above defers every Langfuse dollar amount to Langfuse's own pricing page on purpose. Ours does not need deferring — here it is in full, and it is the whole price list:

Three things that are easy to miss reading it quickly:

• The plan does not gate a single feature. Tracing, prompt management, evals, guardrails, A/B routing, and per-team budgets are on Pay as you go exactly as they are on Enterprise. The plan changes the platform fee and the rate limits, and nothing else.⁴
• There is no free tier and no trial. Signup is card-required and takes a real $5 minimum charge, plus the platform fee on top.⁵ We would rather say that plainly than let you discover it at the payment step.
• No event ceiling. There is no traces-per-month cap, no eval-runs-per-month cap, and no observability-event tier to outgrow. The fee is a percentage of provider spend, so a chatty tracing workload does not cost more than a quiet one at the same spend.

The breakeven arithmetic, out loud. On Pay as you go the fee is a flat 4% of the credits, so buying $S of credits costs $S × 1.04 and the fee is $S × 0.04. Pro's $50/mo pays for itself the moment that fee passes $50 — that is $50 ÷ 4% = $1,250/mo of provider spend. On the annual plan, $500/yr is about $41.67/mo, so the crossover is $41.67 ÷ 4% ≈ $1,042/mo. Below the line, pay as you go is cheaper and you should stay on it; above it, Pro's flat fee wins and your platform fee goes to zero. The canonical table is at /pricing, and the longer version of this decision — including what changes when spend is lumpy month to month — is in from credits to Pro.

Compare that shape against your current Langfuse Cloud plan (or your self-host operating cost) plus whatever your routing layer costs you today: the honest comparison is two invoices against one, not one line item against another.¹

---

Where Langfuse genuinely wins (read this before you switch)

We won't pretend otherwise: Langfuse is excellent at what it does, and there are four specific buyer-states where it is the right call over a full-gateway answer.

1. Your tracing has to stay vendor-neutral at the wire level. Langfuse ingests OpenTelemetry directly, so spans emitted against the OTel generative-AI semantic conventions land without a proprietary SDK in the path.⁶ If "we must be able to point the same instrumentation at a different backend next year" is a hard requirement, that is a real structural answer and it is Langfuse's, not ours.
2. You require OSS self-host with no hosted-vendor dependency on the observability layer. This is a real compliance posture for healthcare, finance, defense, and EU-data-residency teams who cannot route customer prompts through a hosted observability vendor. nRouter is a hosted product; we do not ship a self-host SKU. If self-host is non-negotiable on the observability layer, Langfuse's open-source release at github.com/langfuse/langfuse is a legitimate answer and a structural posture that nRouter explicitly does not compete with.³
3. Observability + prompt management + evals are your buying motion — the LLM gateway is fine as it is. If your team already runs a routing layer you like (homegrown, OpenRouter, or another provider abstraction) and the gap you are filling is specifically "we need versioned prompts, eval pipelines with LLM-as-judge, and per-session traces in one UI," Langfuse is built around exactly that gap. nRouter's value proposition is bundling, not specialist depth on any single primitive — Langfuse's depth on prompt management and eval pipelines is its core product, not a side feature.
4. Your eval pipeline is the load-bearing artifact and you want to own its versioned definitions inside an open-source schema. Langfuse's eval and dataset model is open-source and inspectable; if your audit posture is "prove to a regulator that our eval definitions live in code we control, in an OSS schema, in a self-host we run," Langfuse's open-source release gives you that artifact in a way a hosted gateway cannot.^{3 2}

If any of those four cases is your situation, the rest of this post is not the answer — Langfuse is. The rest of this post is for the other buyer-states.

---

Where nRouter wins (the wedge, axis by axis)

The substantive trade is: a specialist observability layer with OSS self-host (Langfuse) vs a hosted LLM gateway that bundles observability + routing + governance with every feature free on every tier (nRouter). Five axes follow from that trade.

Axis 1 — Surface count, not feature depth

A team running Langfuse for observability + prompt management + evals still owns four other surfaces separately: the LLM routing decision (which model, which provider, which fallback), the multi-provider auth layer (one API key per provider, one rotation policy per provider), the guardrails layer (PII / jailbreak / regex against the classes in the OWASP LLM Top 10⁷), and the per-team / per-customer virtual-key + budget enforcement layer.² Each is a separate integration, a separate vendor relationship (or homegrown service), a separate operational burden, and a separate place an incident can hide.

nRouter consolidates all five surfaces into one OpenAI-compatible base URL, one API key, one console, and one billing relationship.⁴ The wedge here is surface count, not depth on any individual primitive — and for a team whose buying motion is "stop running five separate LLM-infra surfaces," that consolidation is the lever.

Axis 2 — Multi-provider routing is in the gateway, not in front of it

Langfuse instruments the LLM calls your code makes. The provider routing decision (OpenAI vs Anthropic vs Vertex vs Bedrock vs Together vs OpenRouter passthrough) lives in whatever gateway or homegrown SDK abstraction sits in front of Langfuse.² That means three things you have to own yourself: per-provider authentication and key rotation, a fallback chain definition when a provider 429s or 500s, and the cost-and-latency observability that informs the routing decision in the first place.

nRouter ships the models available in your live catalog behind one OpenAI-compatible API key.⁴ The fallback chain is operator-defined, the per-provider auth is one provider-credentials secret managed in the gateway, and the cost-and-latency observability that drives the routing decision is the same dashboard the operator uses to review traces and evals — one surface, not two.

Axis 3 — Governance primitives are free on day one, not delegated downstream

Langfuse's product scope is observability + prompt management + evals + datasets. Guardrails (PII / jailbreak / regex), per-team budgets, per-customer virtual keys, and A/B routing across named models with operator-controlled traffic split — those primitives are not Langfuse's product surface; they live in whatever you run in front of Langfuse.² Per the wedge, nRouter ships every one of those primitives, on every tier, free for life, all isolated per tenant, all available to every customer.⁴

For a buyer whose evaluation question is "what governance + observability surface do I get on day one without paying a tier ladder?", the answer-shape is different in kind, not in degree.

Axis 4 — Platform-fee-only pricing, not per-event capped tiers

Langfuse Cloud pricing is structured around event volume + plan tier; the OSS self-host has its own operating-cost shape (your infra, your DB, your scale).^{1 3} nRouter's pricing is a fee proportional to LLM spend (on pay-as-you-go, 4% of the credits when you buy credits; 0% on Pro) with no observability-event ceiling, no traces-per-month cap, no eval-runs-per-month cap.^{4 5} For a team scaling event volume faster than LLM spend (heavy tracing, dense eval pipelines), the platform-fee shape can be the cheaper invoice even before counting the surface-consolidation savings.

This trade is the substance of the broader pricing-model axis-decision-tree we wrote at the LLM gateway buyer's guide — read it if you want the full pricing-model axis comparison across the gateway market.⁸

Axis 5 — Reservation-arbitrage margin instead of feature-fee margin

nRouter funds the "all features free on every tier" wedge with provider-side reserved capacity: as aggregated customer LLM spend grows, nRouter commits to reserved capacity and dedicated throughput with the model providers on their published commitment terms; customers continue paying full PAYG retail. Pro ($50/mo or $500/yr, 0% platform fee) is the steady-spend upgrade, and aggregated Pro revenue funds annual reservations.^{4 5}

No percentage belongs in that sentence, and we no longer put one there. Each of the three vendors publishes commitment terms rather than a headline discount rate: Azure describes a 1-month or 1-year commitment buying "a discounted effective $/PTU/hr rate" and prints no percentage, and Google and AWS price their reservations per model and per model-unit respectively.^{9 10 11} An earlier revision of this post claimed "yearly up to ~70%, monthly up to ~30%" against those three citations; re-reading all three pages in August 2026 turned up no such figures, so the claim is withdrawn rather than re-sourced. What the arbitrage is worth is a utilization outcome — reserved capacity bills per hour whether or not you fill it — which is why the buyer-facing version of this argument in the cost teardown carries it as a labelled modelling range with a floor of zero, next to levers like batch inference that vendors really do price at a published 50%.

Langfuse's margin engine is per-plan event volume + EE add-on licensing — a legitimate model that lets the OSS self-host stay free and the Cloud tier stay focused on observability primitives.^{1 3} The two engines fund different product surfaces (specialist observability vs gateway-with-observability), and the buyer's answer here depends on which surface they actually need.

---

Switch cost — what a Langfuse → nRouter migration actually looks like

Two integration shapes, depending on which Langfuse surface you're consolidating.

Shape A — Langfuse Cloud + a separate LLM gateway → nRouter. Your code currently calls a gateway (OpenRouter or a homegrown abstraction) and the gateway emits traces to Langfuse Cloud. The switch is two-step:

1. Re-point OPENAI_BASE_URL / SDK base URL from the existing gateway to https://api.nrouter.ai/v1 and swap the API key.⁴
2. Drop the Langfuse SDK init (or keep it during a parallel-run validation window if you want to compare trace fidelity); nRouter's built-in observability surface replaces the Langfuse trace + dashboard layer for the consolidated workload.

Prompt-template definitions stored in Langfuse can be exported via the Langfuse API (langfuse.com/docs) and re-imported into nRouter's prompt-template surface; eval definitions follow the same path (export the eval scoring rubric + dataset, re-create in nRouter's eval primitive).^{2 4}

Shape B — Langfuse Self-host (OSS or EE) + a separate LLM gateway → nRouter. Same two-step at the gateway layer; the self-host operational burden (DB, scaling, EE license tracking, upgrades) goes away after the consolidation window. If the OSS self-host was load-bearing for compliance reasons, nRouter is not the answer — see "Where Langfuse genuinely wins" above.

Either shape, the switch is an afternoon plus a parallel-run validation window. The live-catalog model routing layer is the lever that makes the consolidation worth the afternoon — you replace a gateway + observability vendor pair with one cloud-hosted gateway that ships every governance primitive free on every tier.

---

Migrating your Langfuse-specific config

The base-URL swap moves your traffic. Your Langfuse-specific artifacts are a separate exercise, and they do not all map. What actually happens to each:

The order that works: re-point one non-production route, run both systems in parallel for a week, and compare the request log and the ledger side by side before you move anything else. Reading the ledger is its own small skill — how to read your LLM credit ledger covers what each row means and how it reconciles to what you were billed.

---

When NOT to switch

We will not pretend the migration is universal.

• OSS self-host is non-negotiable — see "Where Langfuse genuinely wins" #1. nRouter is hosted; if compliance posture rules out a hosted vendor on the observability layer, stay on Langfuse Self-host.
• Observability + prompt management is your buying motion, the gateway is fine as it is — see #2. The wedge is bundling, not specialist depth on any single primitive; if specialist depth is the value, the bundle is the wrong shape.
• Eval definitions in an OSS schema are the load-bearing artifact for your audit posture — see #3. The OSS eval schema is the lever; a hosted gateway cannot replicate the open-source posture.

For the other buyer-states — multi-surface consolidation, free-on-every-tier governance, platform-fee pricing on LLM spend rather than event volume, reservation-arbitrage margin instead of feature-fee margin — the rest of this post is the case.

---

Try it without switching anything

The honest test: spin up a nRouter Pay as you go account (no subscription; load the $5 minimum in credits, platform fee on top), point a single non-production route at https://api.nrouter.ai/v1 for a week, compare the traces, eval runs, prompt-template UX, guardrail invocations, and per-team budget enforcement against your existing Langfuse + gateway pair.^{4 5}

If the bundling-into-one-surface saves your team enough operational time and per-call cost to clear the migration afternoon, the Pro plan ($50/mo or $500/yr, 0% platform fee) is the math that compounds for production.⁴ If specialist depth on Langfuse's primitives — open-source eval schema, OSS self-host posture, prompt-template variant workflow — outweighs the bundling, stay on Langfuse. We will be the first to tell you when that is the right answer.

---

See also

• What an LLM Request Log Should Contain — and What to Leave Out — the observability surface nRouter ships on every plan, and how it compares with a self-hosted trace store¹²
• Helicone alternative: governance built in, not gated behind Pro — Helicone is the closest sibling on the observability-first axis but cloud-only¹³
• OpenRouter alternative: every enterprise LLM-gateway feature, free for life — head-term head-to-head¹⁴
• Portkey alternative: every governance feature on every tier, free for life — Portkey vertical head-to-head¹⁵
• LLM gateway buyer's guide 2026 — buyer-stage taxonomy across routing + guardrails + evals + prompt management¹⁶
• LLM routing strategies 2026 — routing-intelligence-shape axis-decision-tree¹⁷
• nRouter pricing — Pay as you go / Pro / Enterprise pricing canonical
• Start on Pay as you go — Pay as you go from $5, platform fee on top

---

Footnotes

Every external claim below traces to that vendor's own pricing, docs, or repository page. Verified 2026-06-10. If a vendor has changed its tiers or its product scope since and we have not refreshed this post, email hello@nrouter.ai and we will re-audit within one business day.

---

Last reviewed 2026-06-10. Every external URL re-audited at port time per cornerstone trifecta convention; defer all Langfuse dollar amounts and per-plan feature gating to vendor URLs to absorb release-cadence drift.

Footnotes

1. Langfuse pricing — current Cloud plan structure (Hobby free tier, Pro, Team, Enterprise), per-plan event volume, OSS-self-host operating model. langfuse.com/pricing (audited 2026-06-10; defer all dollar amounts and per-tier feature gating to vendor URL — competitor pricing drift policy). ↩ ↩² ↩³ ↩⁴ ↩⁵ ↩⁶ ↩⁷ ↩⁸ ↩⁹ ↩¹⁰ ↩¹¹ ↩¹² ↩¹³

2. Langfuse docs — product scope (tracing, prompt management, evals, datasets, playground, annotation queues), framework integrations, SDK matrix, deployment model. langfuse.com/docs (audited 2026-06-10). ↩ ↩² ↩³ ↩⁴ ↩⁵ ↩⁶ ↩⁷ ↩⁸ ↩⁹ ↩¹⁰ ↩¹¹ ↩¹² ↩¹³ ↩¹⁴ ↩¹⁵ ↩¹⁶ ↩¹⁷ ↩¹⁸ ↩¹⁹ ↩²⁰ ↩²¹ ↩²² ↩²³

3. Langfuse open-source repository — OSS release + EE add-on split, self-host deployment artifacts (Docker images, Kubernetes manifests), license boundaries. github.com/langfuse/langfuse (audited 2026-06-10). The self-host operating model and the enterprise-license boundary are documented at langfuse.com/self-hosting — the older langfuse.com/docs/deployment path now 404s (re-checked 2026-08-23). ↩ ↩² ↩³ ↩⁴ ↩⁵ ↩⁶ ↩⁷ ↩⁸ ↩⁹

4. nRouter Business Model + wedge claim. Source of truth for "every feature free on every tier," the pay-as-you-go platform fee (4% of the credits) and 0% on Pro, environment-specific model availability, and the per-tenant-isolated governance primitives (guardrails, A/B tests, prompt management, prompt recommendations, budgets). ↩ ↩² ↩³ ↩⁴ ↩⁵ ↩⁶ ↩⁷ ↩⁸ ↩⁹ ↩¹⁰ ↩¹¹ ↩¹² ↩¹³ ↩¹⁴ ↩¹⁵ ↩¹⁶ ↩¹⁷ ↩¹⁸ ↩¹⁹ ↩²⁰ ↩²¹ ↩²² ↩²³ ↩²⁴ ↩²⁵ ↩²⁶ ↩²⁷ ↩²⁸ ↩²⁹ ↩³⁰

5. Pay as you go, Pro $50/mo or $500/yr, Enterprise custom; reservation arbitrage strategy. ↩ ↩² ↩³ ↩⁴ ↩⁵ ↩⁶

6. OpenTelemetry generative-AI semantic conventions — the vendor-neutral span and attribute names an OTel-native trace store is expected to emit, and what Langfuse's OpenTelemetry endpoint ingests. opentelemetry.io and langfuse.com/docs/opentelemetry (audited 2026-08-23). ↩

7. OWASP Top 10 for LLM Applications — the threat taxonomy behind running guardrails on the request path rather than only reading traces after the fact. owasp.org (audited 2026-08-23). ↩

8. /blog/product/llm-gateway-buyers-guide-2026 — the buyer-stage taxonomy covering PAYG markup, subscription + included-volume, and platform-fee shapes across the gateway market. ↩

9. Azure Foundry provisioned throughput — the hourly PTU meter and the 1-month / 1-year Azure Reservations that discount it. learn.microsoft.com (re-audited 2026-08-23). ↩

10. Google Cloud generative-AI pricing — throughput reservations and committed-use discounts, priced on Google's own page rather than at one headline rate. cloud.google.com (re-audited 2026-08-23). ↩

11. AWS Bedrock pricing, including Provisioned Throughput commitment terms. aws.amazon.com/bedrock/pricing (re-audited 2026-08-23). ↩

12. /blog/guides/llm-observability-request-logs — the fields an LLM request log has to carry to be worth keeping, and what nRouter records on every plan. ↩

13. /blog/product/helicone-alternative — Helicone vertical head-to-head. Closest sibling on the observability-first axis but cloud-only. ↩

14. /blog/product/openrouter-alternative — OpenRouter vertical head-to-head (cornerstone #1). ↩

15. /blog/product/portkey-alternative — Portkey vertical head-to-head. ↩

16. /blog/product/llm-gateway-buyers-guide-2026 — nRouter buyer's-guide cornerstone (cornerstone #3); covers the broader feature taxonomy across routing + guardrails + evals + prompt management at the buyer-stage altitude. ↩

17. /blog/product/llm-routing-strategies-2026 — nRouter routing-intelligence-shape axis-decision-tree cornerstone (axis-decision-tree #1 shipped 2026-06-07); covers the routing-decision-layer shapes (operator-pinned / benchmark-driven / ML-trained classifier). ↩