Helicone is an open-source LLM observability platform whose main draw is simplicity: you add tracking by changing a single line of your code, the client’s base URL. From that moment it logs the cost, latency and tokens of every model call, and throws in caching and rate limiting for good measure. In this guide you will see what Helicone is, the difference between integrating it as a proxy or with its SDK, how it controls cost and latency, how to self-host it with Docker and how it differs from Langfuse. The same explanation is available in Spanish.

Key takeaways

  • Helicone is an open-source LLM observability platform (Apache-2.0 licence), born at the Y Combinator accelerator (batch W23); it has nearly 5,953 stars on GitHub.
  • Its flagship integration is the proxy: you swap your client’s base URL for Helicone’s and gain traceability without touching any more code, with any HTTP client, not just the official SDKs.
  • It logs the cost, latency and tokens of every request, groups calls into sessions and adds caching (the Helicone-Cache-Enabled header) and rate limiting.
  • You can self-host it with Docker: an all-in-one image brings the platform up at http://localhost:3000 and runs on modest hardware, such as a t2.medium EC2 instance.
  • Important note: Mintlify acquired Helicone on 3 March 2026 and the product moved to maintenance mode (security patches, fixes and new models, but no new features). Bear it in mind when choosing a tool.

What is Helicone?

Helicone is an observability platform built for applications that call language models. The idea is simple: when your code talks to OpenAI, Anthropic or any other provider, those calls become a black box that is hard to debug and to bill. Helicone sits in the middle and turns them into data: how much each request cost, how long it took, how many tokens it spent and which prompt and response travelled.

The project was born in Y Combinator’s Winter 2023 (W23) batch and is free software under the Apache-2.0 licence, with nearly 5,953 stars on GitHub. Its official tagline sums it up well: "one line of code to monitor, evaluate and experiment". That promise of zero friction is its biggest selling point against tools that require instrumenting the code by hand.

To give a sense of scale, by March 2026 the platform claimed to have processed 14.2 trillion tokens from 16,000 organisations. Its most recent tagged release is v2025.08.21-1, from 21 August 2025, a date that fits with the maintenance mode we will cover at the end.

Proxy versus SDK integration

Helicone offers two ways to connect, and it is worth understanding the difference before you start.

The first is the proxy, its signature feature. You install no library: you simply change your client’s base URL so it points at Helicone and add a header with your key. The following Python example routes an OpenAI client through Helicone:

from openai import OpenAI

client = OpenAI(
    api_key="your-openai-key",
    base_url="https://oai.helicone.ai/v1",
    default_headers={
        "Helicone-Auth": "Bearer your-helicone-key",
    },
)

response = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "Hello"}],
)

With those two lines (the base_url and the Helicone-Auth header) the whole conversation is logged. Because the proxy works at the HTTP level, it runs with any client, not just OpenAI’s official SDK. Helicone also keeps a unified gateway at https://ai-gateway.helicone.ai that gives access to over one hundred models with the same pattern, in the spirit of a model gateway like OpenRouter.

The second route is the async SDK, based on OpenLLMetry, for Python and JavaScript. Here Helicone does not stand in the request: your code keeps calling the provider directly and the SDK ships the logs separately, adding no latency to the critical path. It is the recommended option if you worry that an intermediary might become a single point of failure or latency. In exchange, it takes a little more instrumentation than the proxy.

Cost, latency and caching

The main reason to put Helicone in place is to stop flying blind on the bill. The dashboard shows, for each request, the calculated cost, the latency, the input and output token counts, and the full prompt and response. You can group related calls into sessions to follow a multi-step flow (for example, all the calls of a LangGraph agent) as a single trace.

On top of observability, Helicone includes a cache that can genuinely save you money. It is switched on with a header:

curl https://oai.helicone.ai/v1/chat/completions \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Helicone-Auth: Bearer $HELICONE_API_KEY" \
  -H "Helicone-Cache-Enabled: true" \
  -d '{"model":"gpt-4o","messages":[{"role":"user","content":"Hello"}]}'

With Helicone-Cache-Enabled: true, identical responses are stored in Cloudflare Workers’ key-value store, distributed at the edge. By default they are kept for seven days (max-age=604800) and you can extend the expiry up to 365 days. This avoids paying twice for the same call during testing, returns responses instantly and protects you from rate limits during traffic spikes. It is an idea related to prompt caching to cut costs, though here the cache holds complete responses, not fragments of the context.

Self-hosting with Docker

If you would rather that neither your prompts nor your metrics leave your infrastructure, Helicone can be self-hosted. The quickest way is its all-in-one Docker image, which brings the whole platform up in a single container reachable at http://localhost:3000:

# Clone the repository and bring the stack up with docker compose
git clone https://github.com/Helicone/helicone.git
cd helicone/docker
./helicone-compose.sh helicone up

Under the hood, Helicone bundles several services: a Next.js web app, the worker that acts as proxy and logger, a log server (Jawn) in Express, a database with Supabase, ClickHouse for analytics and MinIO for object storage. It sounds like a lot, but it is designed to be lightweight: the documentation notes that a t2.medium EC2 instance is enough for most cases, and it ships a Helm chart if you prefer to deploy on Kubernetes. Self-hosting makes full sense when you work with models you run on your own machine with Ollama and want no data to leave your network.

Helicone versus Langfuse

The natural comparison is with Langfuse, the other big self-hostable LLM observability platform. The difference in philosophy is clear.

Helicone bets on the proxy: you change the base URL and you are done, zero refactor. It is the fastest way to start and the one that touches your code least. Langfuse bets on SDK instrumentation over OpenTelemetry: you write a little more code, but in exchange you get richer tracing, prompt management and more complete evaluations, with very active development.

Here comes the deciding factor of 2026: Mintlify acquired Helicone on 3 March 2026 and the product entered maintenance mode, with no new features. If you are starting a long-term project today, that detail matters: Langfuse keeps evolving and is probably the safer bet for the future. Helicone, on the other hand, shines when you want instant observability with minimal effort and do not need the latest features. They are not mutually exclusive: you can start with Helicone’s proxy to get metrics in five minutes and migrate to Langfuse when you need more advanced evaluations.

Frequently asked questions

Is Helicone still alive after the Mintlify acquisition?

Yes, but with caveats. Mintlify acquired Helicone on 3 March 2026 and the project moved to maintenance mode: it will keep receiving security patches, bug fixes and support for new models, but no new features. The repository is still active (last activity in July 2026) and it is Apache-2.0, so you can self-host it without depending on the company. For a project that only needs stable observability, it is perfectly valid; for one expecting constant innovation, it is worth weighing up alternatives.

How much does Helicone cost?

Its cloud version has a free plan with 10,000 requests a month and seven days of retention, and a Pro plan at 79 dollars a month with one month of retention. If you self-host it with Docker, the software is free under the Apache-2.0 licence and you only pay for the infrastructure you run it on, which can be as modest as a t2.medium instance.

Does Helicone’s proxy add latency?

The proxy introduces an extra network hop, so technically it adds a few milliseconds, almost always negligible against the hundreds of milliseconds the model itself takes. Even so, the cache at Cloudflare’s edge can make many repeated responses faster than going to the provider. If that extra latency worries you, use the async SDK, which logs outside the critical path and does not touch the original request.

Conclusion

Helicone is the fastest way to stop flying blind with your calls to language models: you change one line, the base URL, and gain cost, latency, tokens, sessions and caching without refactoring anything. Its open-source Apache-2.0 nature lets you self-host it with Docker on modest hardware and keep your data inside. The important caveat is that, after Mintlify’s acquisition in March 2026, it is in maintenance mode, so for projects expecting new features it is worth weighing up Langfuse. The next step is to point a client’s base URL at Helicone, watch your first traces and decide whether the proxy is enough or you would rather instrument with an SDK.

Sources: [1] Official Helicone documentation[1], [2] Helicone on GitHub[2], [3] Official Helicone site[3], [4] Independent Helicone review at ChatForest[4].

Visitas: 0

Sources

  1. Official Helicone documentation
  2. Helicone on GitHub
  3. Official Helicone site
  4. Independent Helicone review at ChatForest

Route: AI Agents in Production: Evaluation and Reliability