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

The Direct Answer: Langfuse is an observability and tracing specialist that monitors LLM calls after they are made; it does not route traffic, handle model fallbacks, or enforce budget ceilings. nRouter is an inline LLM gateway that bundles real-time OpenTelemetry tracing, multi-provider smart routing, and preflight guardrails behind a single API key with zero per-token markup.

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.

Figure 1: Architectural Comparison: Observability-only SDK wrapper vs Unified Edge Data Plane.

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 pay separately for whatever routes those calls to the model in the first place.^{1 2} You want to know if one tool can collapse routing, observability, and governance into one surface instead of paying two invoices and integrating two SDKs.

2. You self-host Langfuse (the open-source release or EE add-ons) because security or compliance rules out a hosted vendor.^{3 2} You are asking whether a complementary gateway ships every governance primitive on day one so you avoid writing custom guardrails, A/B routing, and per-team budgets alongside your self-host.

3. You're evaluating Langfuse greenfield because the "open-source LLM observability + prompt management + evals" pitch resonates, but you want to know what you do not get in one product.^{1 2} Specifically, what routing, fallback, auth, guardrail, and per-team budget surfaces Langfuse delegates back to the rest of your stack before you commit to a specialist layer.

All three are honest concerns. Langfuse is a real product with a credible thesis: own LLM observability, prompt management, evals, and datasets as a focused specialist layer.^{1 3}

It ships an open-source self-host and a hosted Cloud tier, letting the operator pick whichever fits their compliance and operational posture. For a team whose primary need is "the observability layer is the lever, and the rest of our stack is fine," Langfuse's 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, on every plan, and is the switch (or the alternative pick at greenfield) worth your afternoon?

The short version: every nRouter customer, on every plan, from day one, gets the full LLM governance surface included — guardrails, A/B tests, prompt management, evals, and per-team budgets. Requests route to the models available in your live catalog behind one API key.⁴

Every plan pays the same platform fee: 4% of the credits, charged on top with no minimum fee. No plan varies 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" claim on the nRouter column is real on every plan: guardrails, A/B tests, prompt management, prompt recommendations, and per-team budgets. All are isolated per tenant, available to every customer, with zero feature flags.⁴

Langfuse's column defers to their published docs and pricing pages on every per-plan or per-capability gating row.^{1 2 3} Langfuse ships on its own release cadence (per-plan feature changes, OSS vs EE splits, framework expansions), so quoting rigid numbers here would risk staleness.

The pattern is clear:

• Langfuse is a specialist observability, prompt-management, and evals layer with an OSS self-host option and a hosted Cloud tier. Its primary product surface focuses on observability and eval primitives. Routing, multi-provider auth, fallback chains, guardrails, virtual keys, and per-team budgets are delegated to whichever gateway you run in front of it.²

• nRouter is a full LLM gateway that bundles routing, observability, and governance into one cloud-hosted product. Every governance and observability primitive is included on every plan, and the platform fee on credit purchases is a flat 4% of the credits across all tiers.⁴

The plan varies only the monthly nrouter/auto allowance and default RPM / TPM caps. The central architectural question is straightforward: is observability your standalone buying motion, or do you want an LLM gateway that ships with observability built in?^{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 monthly nrouter/auto allowance 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 fee arithmetic, out loud. On every plan the fee is a flat 4% of the credits. Buying $S of credits costs $S × 1.04 with a fee of $S × 0.04 — so a $100 load is charged $104.00, and you keep the full $100.

A subscription does not lower that fee. Instead, it buys a monthly nrouter/auto usage allowance and higher rate limits. The canonical table is at /pricing, and the longer version of this decision 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, allowing spans emitted against OTel GenAI semantic conventions to land without a proprietary SDK in the path.⁶ If pointing identical instrumentation at a different backend next year is a hard requirement, Langfuse provides that wire-level guarantee.

2. You require OSS self-host with no hosted-vendor dependency on observability. This is a firm compliance posture for healthcare, finance, defense, and EU-data-residency teams who cannot route prompts through a hosted vendor. nRouter is hosted and does not offer a self-host SKU. If self-hosting is non-negotiable, Langfuse's open-source release at github.com/langfuse/langfuse is the proven answer.³

3. Observability, prompt management, and evals are your sole buying motion. If your team already runs a routing layer you like and only needs versioned prompts, LLM-as-judge evals, and session traces, Langfuse is built around that exact gap. nRouter's thesis is bundling; Langfuse's thesis is specialist depth on evaluation workflows and prompt experiments.

4. Your eval pipeline is the load-bearing artifact and requires an open-source schema. Langfuse's eval and dataset model is open-source and inspectable. If your audit posture requires proving to regulators that eval definitions live in code you control inside an OSS schema you self-host, Langfuse provides that guarantee 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 on every plan (nRouter). Five axes follow from that trade.

Axis 1 — Surface count, not feature depth

A team running Langfuse for observability, prompt management, and evals still owns four operational surfaces separately:

• LLM routing: selecting the model, provider, and fallback sequence.
• Multi-provider auth: managing distinct API keys and rotation schedules.
• Guardrails: filtering PII, jailbreaks, and regex against OWASP LLM Top 10 vulnerabilities.⁷
• Tenant governance: enforcing per-team virtual keys and budget limits.²

Each represents a distinct integration, vendor relationship, operational burden, and potential failure point during an incident.

nRouter consolidates all five surfaces into one OpenAI-compatible base URL, one API key, one console, and one billing relationship.⁴ For teams whose primary goal is to stop maintaining five disconnected LLM-infra surfaces, this consolidation is the deciding 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 architecture leaves three surfaces for your team to manage:

• Provider credentials: authenticating and rotating keys for each provider.
• Failover topology: handling fallback chains when a provider returns 429 or 500.
• Routing telemetry: tracking the cost and latency metrics needed to inform routing.

nRouter ships the models available in your live catalog behind one OpenAI-compatible API key.⁴ Fallback chains are operator-defined, provider authentication is handled securely in the gateway, and cost-and-latency telemetry shares the same dashboard used for traces and evals — one surface, not two.

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

Langfuse's core scope encompasses observability, prompt management, evals, and datasets. Upstream governance primitives — such as PII/jailbreak guardrails, per-team budgets, per-customer virtual keys, and traffic-split A/B testing — are delegated to whatever gateway sits in front.²

By contrast, nRouter includes every one of those governance primitives on every plan. All are isolated per tenant and available to every customer on day one.⁴

For a buyer asking "what governance and observability surface do I get on day one without climbing a tier ladder?", the architecture differs in kind, not just degree.

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

Langfuse Cloud pricing is structured around event volume and plan tiers, while its OSS self-host incurs infrastructure, database, and operational costs.^{1 3}

nRouter charges a flat platform fee proportional to LLM spend: 4% of credits at purchase on every plan. There are no event ceilings, no monthly trace caps, and no eval-run limits.^{4 5}

For teams scaling event volume faster than LLM spend (such as dense evaluation pipelines and heavy tracing), a usage-fee model often results in a significantly lower total bill before even factoring in operational savings.

This trade is explored in depth in our pricing-model analysis at the LLM gateway buyer's guide — see it for full comparisons across the gateway market.⁸

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

nRouter funds the "every feature on every plan" wedge with provider-side reserved capacity. As aggregated customer LLM spend grows, nRouter commits to reserved capacity and dedicated throughput with model providers under their published commitment terms, while customers pay standard PAYG retail rates.

Subscriptions (Starter $20/mo, Pro $50/mo, Max $200/mo) pay the same 4% platform fee and add a monthly nrouter/auto allowance for predictable spend.^{4 5}

No percentage belongs in that sentence, and we no longer put one there. Each of the three major cloud vendors publishes commitment terms rather than a headline discount rate. Azure describes commitments as buying "a discounted effective $/PTU/hr rate" without quoting a percentage, while Google Cloud and AWS price 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 citations. Re-reading all three vendor sources confirmed no such figures exist, so the claim was withdrawn rather than re-sourced.

What capacity arbitrage yields in practice depends strictly on utilization, since reserved instances bill hourly whether filled or idle. That is why our analysis in the cost teardown models this as a range with a floor of zero, distinct from levers like batch inference that vendors publish at a flat 50% discount.

Langfuse's margin engine is built on per-plan event volume and EE add-on licensing. This structure keeps its open-source self-host free while funding Cloud tier observability features.^{1 3}

The two financial models support distinct product surfaces: specialist observability versus a gateway with built-in governance. The right choice depends on which surface your architecture requires.

---

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. The migration follows the same two-step process at the gateway layer. The operational overhead of running a self-host (database maintenance, scaling, license tracking, and upgrades) is eliminated after the cutover window.

If the OSS self-host was required for strict data governance, nRouter is not the intended solution — see "Where Langfuse genuinely wins" above.

In either case, the migration takes an afternoon followed by a parallel-run validation period.

The live-catalog model routing layer is the key benefit: you replace a separate gateway and observability vendor pair with a single cloud-hosted platform shipping every governance feature on every plan.

---

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 ledger side by side before migrating production traffic.

Reading the ledger is its own operational skill. How to read your LLM credit ledger details what each row represents and how it reconciles with your invoice.

---

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, every-feature-on-every-plan 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 an nRouter Pay as you go account (no subscription required; 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 traces, eval runs, prompt templates, guardrail checks, and per-team budget controls directly against your existing setup.^{4 5}

If consolidating into one surface saves enough engineering time and per-call cost to justify the migration, an active subscription (from $20/mo, with a monthly nrouter/auto allowance and higher rate limits) is the next production step.⁴

If specialist depth on Langfuse's specific primitives — such as open-source eval schemas, an on-premise self-host, or prompt variant workflows — remains your top priority, stay with Langfuse. We will be the first to tell you when that is the better choice.

---

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, on every plan — head-term head-to-head¹⁴

• Portkey alternative: every governance feature, on every plan — 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 / Starter / Pro / Max / 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 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 on every plan," the platform fee (4% of the credits, the same on every plan), 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, Starter $20/mo, Pro $50/mo, Max $200/mo, 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). ↩