Langfuse vs Helicone: tracing, evaluation, gateways, and cost analysis.

You want to see what your LLM application is doing and what it costs. Langfuse and Helicone are both open-source answers to that question, and they start from opposite ends. Langfuse instruments your application code. Helicone sits in the request path as a gateway. Almost every difference below follows from that one choice.

Everything here comes from each vendor’s own documentation and announcements, read on 2026-09-24. Both companies were acquired this year, so status comes first, then the products dimension by dimension, then when each fits and what to do once you know which calls cost the most.

• Instrumentation. Langfuse uses SDKs built on OpenTelemetry, or any OpenTelemetry exporter, and stays out of the request path. Helicone takes a base URL change to its AI Gateway; an async mode exists, but it gives up the gateway features.
• Tracing. Langfuse records nested trees of typed observations grouped into sessions. Helicone logs one row per request and builds sessions and trees from headers you send.
• Evaluation. Langfuse runs evaluations: LLM-as-a-judge, code evaluators, annotation queues, datasets, experiments, and CI checks. Helicone stores scores and feedback computed elsewhere and says it is not an evaluation framework.
• Prompts. Both version prompts outside your code. Langfuse serves them through its SDKs with a client-side cache; Helicone can assemble them inside the gateway from a prompt ID.
• Gateway and caching. Helicone routes across providers, fails over, caches responses at the edge, and enforces rate limits. Langfuse does none of that by design and pairs with a gateway instead.
• Cost. Both compute per-call cost and slice spend by user, session, and custom dimensions.
• Self-hosting. Langfuse’s core is MIT-licensed, with enterprise add-ons under a separate license. Helicone is Apache 2.0.
• Status. ClickHouse acquired Langfuse, announced 2026-01-16, and Langfuse stays open source. Mintlify acquired Helicone, announced 2026-03-03, and its services stay live in maintenance mode.

Langfuse announced on 2026-01-16 that ClickHouse had acquired it. The post says Langfuse stays open source and self-hostable with no planned licensing changes, that Langfuse Cloud keeps running with the same endpoints, and that the whole team is joining ClickHouse to keep building the product. The two were already close: Langfuse moved its core data layer to ClickHouse with its v3 release.

Helicone announced on 2026-03-03 that Mintlify had acquired it and that its team is joining Mintlify. In Helicone’s words, its services will remain live for the foreseeable future in maintenance mode, which it spells out as security updates, new models, and bug and performance fixes that keep shipping. The public repository matches that description: as of 2026-09-24, the latest commit on its main branch is a security fix dated 2026-09-16.

Neither announcement changes how either product works today. Maintenance mode still matters for a long-lived decision, more for the system that holds your evaluation history and prompt versions than for a gateway behind one base URL.

Langfuse’s SDKs, Python v4 and JS/TS v5 as of 2026-09-24, are built on OpenTelemetry. You wrap functions or open observations in code, and the SDK queues events and flushes them in batches in the background. Langfuse says this adds almost no latency and that SDK errors are caught and logged rather than raised into your application. Anything that already emits OpenTelemetry can send OTLP straight to Langfuse’s /api/public/otel endpoint, and Langfuse maintains integrations for a long list of agent frameworks and model SDKs.

One date matters if you wrote a custom integration: on Langfuse Cloud, the legacy POST /api/public/ingestion endpoint stops accepting everything except scores on November 16, 2026, and Langfuse’s ingestion migration guide moves that code to OpenTelemetry.

Helicone’s primary integration is a base URL. Point the OpenAI SDK at https://ai-gateway.helicone.ai with a Helicone API key, and every request is forwarded, logged with its cost, latency, and errors, and returned. Helicone runs its proxy on Cloudflare Workers and publishes its own benchmark showing proxied latency closely matching direct calls to OpenAI. If you would rather keep Helicone off the critical path, its async integration logs through OpenLLMetry or a manual logger, but Helicone’s own comparison table marks caching, retries, and custom rate limits as proxy-only.

The trade is the usual one. A proxy captures everything from one line of configuration and can act on each request, and it becomes a dependency of every call. SDK instrumentation stays out of the path and sees the structure of your code, and it asks for code changes wherever you want detail.

Langfuse models a trace as a tree of typed observations: spans, generations, agents, tools, chains, retrievers, embeddings, evaluators, guardrails, and events. Framework integrations set the types for you. Propagate a session ID and traces group into a session you can replay, share as a public link, bookmark, or score by hand. Agent graphs, user tracking, tags, environments, and full-text search sit on top.

Helicone’s unit is the request. Three session headers, Helicone-Session-Id, Helicone-Session-Path, and Helicone-Session-Name, group requests into a session, and path syntax such as /abstract/outline builds the parent-child tree. Sessions can include vector database queries and tool calls logged through Helicone’s logger SDKs, not only model calls. Custom properties, sent as headers named Helicone-Property- followed by the property name, tag each request for filtering and segmentation.

For a chat app or a short chain, either view is enough. For a multi-step agent whose failures happen between model calls, the difference is where the structure comes from: Langfuse captures it from your code, and Helicone reconstructs it from the session paths you send.

This is the widest gap between the two. Langfuse runs evaluations. Managed LLM-as-a-judge evaluators score live observations or experiment runs, with numeric, categorical, or boolean results. Code evaluators handle deterministic checks, annotation queues route traces to human reviewers, and scores also arrive through the UI, the API, or the SDKs. Datasets hold inputs and expected outputs, often built from production traces, and experiments run your application over a dataset from the UI, the SDK, or OpenTelemetry so you can compare runs side by side. The langfuse/experiment-action GitHub Action fails the job in a pull request workflow when your experiment script flags a score that violates your threshold. Since June 2025, the judge, playground, prompt experiments, and annotation features have been MIT-licensed along with the rest of the core.

Helicone is explicit about its scope. Its scores documentation says it does not run evaluations and is not an evaluation framework. It stores the scores you compute elsewhere, as integers or booleans attached to a request through the API or the dashboard, alongside user feedback. Its Datasets feature curates logged requests into sets you export as JSONL for fine-tuning or CSV for analysis. Helicone’s prompt Experiments feature is marked deprecated in its docs, with removal dated September 1, 2025.

If running evaluations is the job you are hiring a tool for, Langfuse is built for it and Helicone says it is not.

Both keep prompts out of your deploy cycle. Langfuse versions prompts and promotes them with labels such as production and staging, with variables, composable prompts, config, a playground for side-by-side comparisons, webhooks, and a GitHub integration. Linking prompts to traces lets you compare versions on cost, latency, and quality. The SDKs cache prompts client-side; Langfuse says this adds no latency after first use, and you can pre-fetch prompts at startup or ship a fallback.

Helicone versions prompts with environments for production, staging, and development, supports variables anywhere including tool schemas, and has its own playground. Its distinctive part is delivery: send a prompt_id and inputs to the AI Gateway, and it assembles the prompt on the way through, with no extra SDK in your application.

Helicone’s AI Gateway is one OpenAI-compatible endpoint for 100+ models, by Helicone’s count. Request a model and, per Helicone’s routing docs, the gateway finds the providers that serve it, routes to the cheapest, load-balances providers of equal cost, and fails over on rate limits, timeouts, and server errors. You can pin one provider, target your own deployment, or write an explicit fallback chain. Your own provider keys are tried first, with Helicone’s managed keys as the fallback, paid from credits that Helicone says carry 0% markup. Around that sit custom rate limits by request count or spend, set globally, per user, or per custom property, plus LLM security checks for prompt injection and handlers for requests that exceed a model’s context window.

Langfuse has no gateway and does not route, cache, or throttle model calls. It pairs with one: its integration docs cover LiteLLM Proxy, Portkey, OpenRouter, Vercel AI Gateway, Kong, TrueFoundry, and Helicone itself. Langfuse’s LLM connections exist so its playground and judges can call models, not to carry your production traffic.

Helicone caches whole responses at the edge, in Cloudflare Workers KV. You turn it on per request with the Helicone-Cache-Enabled header. The cache key hashes the URL, the request body, and the relevant headers, so any parameter change is a miss. Cache-Control sets the lifetime, seven days by default; a cache seed partitions entries, per user for example; and buckets store several responses for the same request. Separately, the gateway passes provider prompt caching through, which lowers the provider’s rate for repeated prompt content rather than skipping the call.

Langfuse’s caching is about prompts, not responses: the SDK cache described above, plus server-side prompt caching. Response caching, if you want it, belongs to the gateway you pair it with.

Both compute per-call cost and let you slice the spend. Langfuse records usage and cost per usage type, such as input, output, and cached tokens, on every generation. Costs are either ingested from your integration or inferred from model definitions. Langfuse ships prices for popular OpenAI, Anthropic, and Google models, you add custom definitions with pricing tiers for anything else, and ingested values win when both exist. Custom dashboards, threshold alerts routed to Slack, GitHub Actions, or webhooks, and the Metrics API break cost and latency down by model, user, session, feature, release, and prompt version.

Helicone computes cost at the gateway from its model registry, which Helicone labels 100% accurate for gateway traffic, and falls back to a best-effort estimate from its open-source pricing repository of 300+ models for direct integrations. Sessions show what a whole interaction cost, custom properties slice spend by feature, user tier, or environment, and alerts fire on cost, error rate, latency, or token counts. Weekly reports go to email or Slack. HQL lets you query request data in SQL; as of 2026-09-24 it is available to selected workspaces.

A cost view answers where the money goes. It cannot say whether a cheaper model would have produced an acceptable answer on those same calls. That takes a replay, which is where the last section picks up.

Langfuse’s repository license puts everything outside its ee directories under MIT, and since June 2025 that core includes evaluation, the playground, experiments, and annotation. A license key unlocks enterprise add-ons such as SCIM, audit logs, data retention policies, and project-level RBAC. Self-hosted Langfuse runs the same codebase as Langfuse Cloud: web and worker containers on Postgres, ClickHouse, Redis or Valkey, and S3-compatible storage, with Docker Compose for local use and Helm or Terraform modules for AWS, Azure, and GCP in production.

Helicone is licensed under Apache 2.0. Its docs cover an all-in-one Docker image, Kubernetes Helm charts, manual installation, and cloud deployment. One detail for anyone planning a self-hosted proxy: Helicone’s Docker guide notes that its Jawn service no longer proxies model traffic, so you run the AI Gateway alongside it.

Langfuse exposes a public API, an Observations API for row-level data, a Metrics API for aggregates, UI exports, a CLI, an MCP server, and an OpenAPI spec. Scheduled exports write to S3, Google Cloud Storage, or Azure Blob Storage anywhere from every 20 minutes to weekly; as of 2026-09-24 that feature is available self-hosted, on Enterprise, or on Pro with the Teams add-on.

Helicone exposes a REST API to query requests, with bodies included when you ask for them, and an export CLI, @helicone/export, that writes JSON, JSONL, or CSV with date and property filters. Datasets export separately, and HQL covers ad hoc SQL. Whichever tool you run, a periodic export keeps your history portable.

Helicone fits when the problem is traffic. You want one OpenAI-compatible endpoint across providers, failover, edge caching, rate limits by user or spend, and per-request cost, all from a base URL change. Weigh the maintenance-mode status against how long you expect to depend on it and on its roadmap.

Langfuse fits when the problem is quality and structure. You want nested traces of agents, evaluations that run on live traffic and in CI, datasets and experiments, prompt management with client-side caching, and the option to self-host all of it under MIT.

Both fit when you want a gateway and an evaluation platform. Langfuse documents the combination: point its OpenAI SDK wrapper at Helicone’s AI Gateway base URL, and Helicone routes and caches while Langfuse traces and evaluates. Both will compute a cost for the same call, so pick one as the system of record for spend. Langfuse’s Helicone migration guide notes that the two capture mechanisms don’t conflict, which is also what makes a gradual migration practical.

Both tools will show you which steps dominate the bill. The next question is whether each of those steps needs the model it runs on. Langfuse experiments can answer that on a curated dataset with evaluators you configure. The other route is the production traffic you have already recorded, judged against the outputs your team already accepted.

That is the job rightmodeler does. It is an MIT-licensed command-line tool that reads exported traces, replays recorded model calls through cheaper candidates from your provider’s live model catalog, and judges every candidate against the output you shipped. The evidence rules are strict on purpose: a step family needs at least 10 assessed executions, two distinct step IDs, and five distinct trajectories, and below any of those it abstains with a named reason. Candidates are shortlisted on one half of the cases and must clear the quality floor again on held-out cases. When a family clears every gate, rightmodeler opens a draft pull request that changes model identifiers and nothing else, for a person to review and merge. It never sits in your request path.

It has dedicated adapters for both tools. From Langfuse, export observations and rightmodeler replays the GENERATION records; pass --evaluator langfuse and your own Langfuse scorers grade the replays, and the results can go back into a Langfuse dataset. From Helicone, export request rows with their bodies included; rows that share a Helicone-Session-Id become one trajectory, so a multi-call agent run counts as one unit in the statistics rather than many. A plan mode previews the pipeline without spending anything, and a cost cap bounds replay spend. The exact export and run commands are in the Langfuse integration guide and the Helicone integration guide.

For how rightmodeler relates to each product in more depth, read rightmodeler vs Langfuse and rightmodeler vs Helicone. If you are weighing evaluation platforms more broadly, we also compare it with Braintrust and LangSmith, and the reduce LLM costs guide walks through the full workflow. For the levers beyond a model swap, such as caching, batching and compression, read which LLM cost optimization approach fits your workload.