LLM Observability: Langfuse vs LangSmith vs Helicone Cost Playbook

A support agent answers 40,000 chats a month — each chat one trace of a dozen model calls, tool calls and retrieval steps — and the model bill lands at $12,000. Then the observability invoice arrives: the tracing tool costs almost half as much as the models, because nobody read the meter. Langfuse bills units, LangSmith bills traces in LangChain Standard Units, and Helicone bills proxy requests. The same workload costs $175 a month on one vendor and $5,145 on another. This playbook runs the same volumes through all three price lists, names the retention charges that double the bill, and ends with an eight-step decision procedure.

The three meters are not the same thing

The three vendors define tracing the same way and disagree on what to count. A LangSmith trace is one execution of your application — an agent run, an evaluator run, a playground session — capped at 25,000 runs per trace. Langfuse counts units, tied to the observations inside traces, and its pricing page does not publish how many units a trace consumes. Helicone counts requests through its proxy: one request is one model call, so an agent turn with five tool calls is at least five requests. Lining up 1 million traces against 1 million requests against 1 million units as if they were the same quantity is wrong.

Two provenance notes. LangSmith's per-trace rate — 0.005 LSU per additional base trace, plus 0.0025 LSU for the extended-retention upgrade — is not in the static text of the pricing page; it lives in the page's usage tooltip and calculator, corroborated by four independent trackers. Helicone's Pro price of $79 a month is corroborated the same way: the page's calculator prices 100,000 requests at $87.73, exactly $79 plus nine blocks of $0.97 per 10,000 requests.

Plan cards at a glance

The free tier, the paid base and the enterprise route for each vendor:

The monthly cost math, reproduced

Langfuse charges a flat base plus tiered overage: first 100,000 units included, then $8, $7, $6.50 and $6 per 100,000 units across the bands to 1M, 10M and 50M. The calculator confirms it: 200,000 units on Core is $37 a month:

LangSmith charges seats plus traces: five seats on Plus is $195 a month, the plan includes 10,000 base traces, every trace past the allowance costs 0.005 LSU (1 LSU = $1.00), seats bill on the 1st, traces in arrears:

Helicone: flat base plus $0.97 per additional 10,000 requests past the 10,000 included:

For the token rates behind the model spend, see the OpenAI vs Anthropic vs Google LLM API pricing playbook.

Worked example: a support agent at one million traces

Take the opening agent: 1,000,000 traces a month, a $12,000-a-month provider invoice for model tokens (a worked-example input, not a vendor price), and a five-person team. For Langfuse, assume 8 observations per trace, which gives 8,000,000 units. For Helicone, assume one proxy request per trace, noting that each tool call through the proxy adds a request. Check whether the observability bill earns its keep: run the monthly total against the model invoice in the ROI Calculator before renewing a paid plan.

Langfuse at 8,000,000 units on Core: $29 + $72 for the 100,000-to-1-million band + 70 blocks of $7 for the 1-to-10-million band = $591 a month. LangSmith at 1,000,000 traces on Plus with five seats is $5,145 a month; Helicone at 1,000,000 requests on Pro is $175.03 a month. Against the $12,000 model bill, observability is 4.9% of model spend on Langfuse, 42.9% on LangSmith and 1.5% on Helicone. At 42.9% the tracing tool is no longer a rounding error: sample traces, shorten retention, or negotiate an Enterprise contract. Run the same arithmetic with your own spans per trace before signing. The self-hosting LLMs and vector databases cost guide covers the infrastructure side.

Retention: the second bill

Retention is where observability bills quietly double. Langfuse prices it as a plan feature: Hobby 30 days, Core 90 days, Pro and Enterprise 3 years, with scheduled retention management on Pro. No per-trace surcharge; you pay for the plan that holds the window you need.

LangSmith prices retention per trace: base 14 days, extended 180 days, upgrade +0.0025 LSU per trace ($0.005 to $0.0075). At 1 million traces, upgrading everything adds $2,500 a month ($5,145 to $7,645 on Plus). The trap is the automatic upgrade: LangChain's billing documentation states online evaluators and automation rules can extend a trace at higher cost, a matching rule upgrades the whole trace, thread-level rules upgrade every trace in the thread, and API or SDK feedback with retention extension enabled upgrades the trace too. Experiments are created at extended retention by default.

Helicone prices retention as a plan feature: Hobby 7 days, Pro 1 month, Team 3 months, Enterprise forever. Seven days debugs yesterday's incident; it does not build a quarterly quality report. The mitigation is the same everywhere: keep short retention in the tracing tool and move the traces that matter into a dataset or an export. LangSmith datasets have indefinite retention; Langfuse offers scheduled batch export to blob storage on the Teams add-on. Decide retention before the first production trace lands.

Token-cost attribution per trace and per model

All three vendors attribute token usage and cost to traces, at different granularity. Langfuse lists token and cost tracking on every plan, with user and session tracking alongside it, for cuts by user, session, model and prompt version. Its dashboards analyse cost, latency, volume and quality together.

LangSmith's trace is the attribution boundary: one trace is one execution, and cost rolls up to it. That is straightforward when one trace equals one user request, and misleading for a 200-step agent loop, where the per-step cost hides inside the trace cost. Hourly ingestion limits are a second boundary: 500,000 events and 5 GB on Plus, and 50,000 events and 500 MB an hour on Developer with no payment method.

Helicone attributes cost per request through the proxy, with custom properties and user identifiers for cuts by customer or feature. The proxy sees each model call separately, so per-model cost is exact; per-conversation cost has to be assembled from the session's requests. Your provider bill stays with your provider, and Helicone charges only for the observability layer — which is why its bill stays small at high volume.

Evals, datasets, prompts and playgrounds

Langfuse includes datasets, experiments through the SDK and the UI, custom evaluation scores, user feedback tracking, LLM-as-a-judge evaluators and annotation queues on every plan — 1 on Hobby, 3 on Core, unlimited on Pro. LangSmith's evaluation surface is its deepest feature: online and offline evals, dataset collection, annotation queues, and Tuned Evaluators at 0.015 LSU per successful run — 10,000 runs cost $150; failed and skipped runs are not billed. Helicone includes prompts, scores, datasets and a playground on paid plans.

Prompt management is the second half of the story. Langfuse versions prompts, fetches them with unlimited calls, manages releases, and runs prompt experiments in its playground on every plan. LangSmith's Prompt Hub and Playground serve the same role. Helicone's playground and prompt versioning sit behind the proxy. The test is the workflow: version a prompt, run it against a dataset, score the outputs, promote the winner. The difference is whether the eval run itself is billed — LangSmith's Tuned Evaluators are, Langfuse's LLM-as-a-judge evaluators ride on your own model key, and Helicone's scores are computed in the platform. Check the AI agent evaluation harness accuracy playbook for the scoring methods.

Self-host vs cloud

Self-hosting changes the bill from a meter to a server. Langfuse is the only vendor whose core product is open source and self-hostable without a sales conversation: Docker Compose locally, Kubernetes with Helm or AWS, Azure and GCP for production, on Postgres, ClickHouse, Redis and S3. Its documentation states the self-hosted deployment runs the same codebase as Langfuse Cloud, processes 110 billion-plus observations a month, and has passed 38 million Docker pulls. The autonomous AI agents production architecture covers the tracing layer in a production agent deployment.

LangSmith reserves self-hosted and hybrid deployment for Enterprise, priced by sales, invoiced annually upfront. Hybrid keeps the control plane in LangChain's cloud and the data plane in your VPC. For a team that cannot send prompts to a third party, Enterprise is the only LangSmith route.

Helicone offers on-prem deployment on its custom Enterprise plan, with a custom MSA and SAML SSO. The hosted tiers carry a different consideration: Helicone announced on March 3, 2026 that its founding team was joining Mintlify and the service would continue in maintenance mode; the pricing page carries a banner stating Helicone is now part of Experiential Labs. Maintenance mode means security updates and new-model support continue while feature development has stopped. Confirm signup, support and roadmap position with the vendor before committing to a hosted tier.

Choose in eight steps

1. Measure real volume for two weeks: traces per month, median spans per trace, requests per trace.
2. Convert the volume into each vendor's meter with the formulas above, using your own spans-per-trace number.
3. Price retention separately from ingestion: decide the debugging and reporting windows, then check which plan holds each.
4. List every automation rule, online evaluator and feedback integration, and mark which auto-upgrade traces to extended retention.
5. Run one dataset evaluation end to end per shortlisted vendor: version a prompt, run it against 100 traces, score the outputs, promote the winner.
6. Test the ingestion ceiling with a burst: confirm the limits hold your peak, not just your average.
7. Price the exit: confirm bulk export works on your tier and preserves the traces you would need to rebuild history elsewhere.
8. Sign the shortest commitment that holds your price, and re-run the three formulas quarterly — all three vendors changed their meters in 2026.

Execution checklist

• [x] Volume measured: traces, spans per trace, requests per trace
• [x] Cost modelled at 1M, 10M, 50M in each vendor's own meter
• [x] Retention windows decided for debugging and reporting separately
• [x] Auto-upgrade rules audited before evaluators go live
• [x] One dataset evaluation run end to end on the shortlist
• [x] Burst test passed against the ingestion ceiling
• [x] Bulk export confirmed on the chosen tier
• [x] Quarterly re-price scheduled against the live pricing pages

The decision in advance

On LangChain and LangGraph, LangSmith is the natural fit and the expensive one: $5,145 a month at 1 million traces on Plus with five seats, before retention upgrades. For open source and a self-hosted exit, Langfuse is the natural fit: $101 a month at 1 million units on Core, with the bill driven by spans per trace. For the cheapest hosted tracing on chat-shaped traffic, Helicone is the natural fit: $175.03 a month at 1 million requests on Pro — if 1-month retention and maintenance-mode status are acceptable. Run your own numbers through the formulas above, then pick the meter that matches your architecture.