Every LLM app hits the same uncomfortable morning: the provider invoice arrives and nobody can say which feature spent the money. Helicone, Langtrace and Langfuse all answer that question — but they make you pay for the answer in different currencies: one takes a proxy hop, two take a few lines of SDK code, and only one hands you a full evals platform on top. If the number you actually watch is spend, here's how to choose without instrumenting all three.

The one-decision version#

Everything below is why.

Helicone: change one URL, see the money#

Helicone is a proxy. You point your existing client at Helicone's base URL instead of the provider's, and every call is logged — token counts, dollar cost, latency, status — with no SDK and no restructuring. In Python against an OpenAI-style client, the whole integration is the base_url:

from openai import OpenAI

client = OpenAI(
    base_url="https://oai.helicone.ai/v1",   # the only change
    api_key=OPENAI_API_KEY,
    default_headers={"Helicone-Auth": f"Bearer {HELICONE_API_KEY}"},
)
# every request through `client` is now logged with cost + tokens

It adds roughly 5ms P95 overhead, the free tier covers 10,000 requests/month, and paid starts around $79/month. The catch is architectural, not financial: your traffic now flows through a proxy you don't run. For many teams that's fine; for some — regulated data, latency purists, anyone allergic to a third party in the request path — it's a non-starter. If that's you, skip to the SDK options.

Langtrace: OpenTelemetry spans, nothing you don't need#

Langtrace sits in the middle. It's an OpenTelemetry-native SDK: you initialize it in code, and it emits standard OTel spans carrying token counts, duration and per-request cost. Two lines and your existing LLM and vector-DB calls are traced:

from langtrace_python_sdk import langtrace
langtrace.init(api_key=LANGTRACE_API_KEY)
# your OpenAI / Anthropic / LangChain / LlamaIndex calls now emit OTel spans

The value here is portability, not features. Because the output is plain OTel, your cost data isn't trapped in a vendor's schema — any OTel backend (including Grafana, or your own collector) can ingest it, and you can leave without a migration. The trade-off is scope: Langtrace is tracing-focused. It shows you what happened and what it cost; it won't run your evals or manage prompt versions. If your only job right now is "put spend into the OTel pipeline I already run," it's the cleanest fit.

Langfuse: own the data, grow into evals#

Langfuse is the platform. Its core is MIT-licensed and can be fully self-hosted for free (Docker Compose to start, Helm/Terraform for production), so unlike a proxy, the data never has to leave your infrastructure. Cost tracking is table stakes here — the differentiator is that Langfuse lets you slice spend by prompt version and trace, which is exactly the view you need once the question graduates from "what did today cost" to "which prompt is the expensive one." It's OTel-native on ingestion, and it carries prompt management, datasets and LLM-as-judge evals for when observability turns into optimization.

A proxy tells you the bill. A self-hosted platform tells you the bill and lets you keep the receipts.

Two footnotes that matter. First, cloud pricing starts around $29/month if you'd rather not operate it. Second — ClickHouse acquired Langfuse in January 2026 (our take here); the open-source core remains, but if long-term licensing or hosting guarantees are load-bearing for your org, confirm the current terms before you standardize. The step-by-step wiring lives in how to instrument an agent with Langfuse v4 and OTel.

The honest trade#

The axis nobody markets is instrumentation effort vs. ownership. Helicone is the least code and the least control — a URL swap that routes you through someone else's proxy. Langtrace and Langfuse cost you a few SDK lines but keep the request path yours and the data OTel-portable. If you just need the number today, proxy in and move on. If the spend data is going to live in your dashboards for years, spend the twenty minutes on the SDK and self-host — future-you, staring at a five-figure invoice, will want to slice it by prompt. For a wider look at the eval-heavy end of this market, we compared Langfuse vs LangSmith vs Braintrust separately.