Helicone Review (2026): Features, Pricing & Verdict
On 3 March 2026, documentation platform Mintlify acquired Helicone, and founders Justin Torre and Cole Gottdank joined Mintlify in San Francisco. Helicone’s services remain live in maintenance mode — security patches, bug fixes and new-model support keep shipping — but active feature development has stopped, and cloud customers are being encouraged to plan migration to alternative platforms. Crucially, Helicone’s core is open-source under Apache 2.0 and fully self-hostable, so unlike a fully shut-down product it can still be run and owned indefinitely. This review credits Helicone’s genuinely excellent architecture while being clear-eyed about what maintenance mode means for anyone adopting it today.
Helicone is an open-source LLM observability platform and AI gateway that earned its reputation on one genuinely clever idea: the lowest-friction integration in the entire category. Rather than asking you to wrap your LLM client in a new SDK, Helicone asks you to change a single line — your API base URL — and you’re in production observability in under five minutes. Founded in 2023 by Justin Torre and Cole Gottdank and part of Y Combinator’s W23 batch, Helicone grew into one of the most-used LLM observability tools among startups, serving more than 16,000 organisations and processing over 14.2 trillion tokens across three years. Its architecture is a proxy: Helicone sits between your application and the LLM provider, logging every request and response, tracking tokens and cost, and applying configured behaviours — caching, rate limiting, custom metadata — before forwarding the call. In June 2025 it extended that proxy into the Helicone AI Gateway, a Rust-built unified routing layer giving access to more than 100 models through a single OpenAI-compatible endpoint, with automatic failover, cost-based routing, caching and load balancing bundled natively — a combination no pure-observability rival matched. It’s licensed under Apache 2.0, fully self-hostable via Docker and Helm, SOC 2 and GDPR compliant, and priced with a generous free tier. There is, however, an unavoidable caveat that shapes any 2026 assessment: in March 2026 Mintlify acquired Helicone and moved the product into maintenance mode. The proxy still works, the open-source code still ships bug fixes and new models, and self-hosting remains fully viable — but new feature development has ended, and cloud customers are being pointed toward migration. For a fast-moving ecosystem, that changes the calculus for new adopters, which is why this excellent-but-frozen platform lands where it does.
- Status
- Maintenance mode (acquired by Mintlify, Mar 2026) — live, security/bug/model updates only; no new features; migration encouraged; open-source & self-hostable
- What it is
- Open-source LLM observability platform + AI gateway: one-line proxy integration, cost/latency tracking, tracing, prompt management, and 100+-model routing with caching, fallbacks & rate limiting
- Best for (today)
- Teams that specifically want a self-hosted (Apache 2.0) proxy combining observability and a gateway, and will own the maintenance burden — or existing users while they plan migration
- Pricing
- Self-host free (Apache 2.0); Hobby free (10k requests/mo); Pro from ~$20/seat/mo; Team/Enterprise higher; SOC 2 & GDPR
- Vendor
- Helicone (YC W23; founders Justin Torre & Cole Gottdank) — acquired by Mintlify Mar 2026; 16,000+ orgs, 14.2T+ tokens; ~5,700 GitHub stars
What Is Helicone?
Helicone is an open-source LLM observability platform and AI gateway — a single integration that lets developers monitor, debug, analyse and route their LLM traffic across more than 100 models. Its defining characteristic, and the reason it stood out in a crowded field, is architectural: Helicone is proxy-first. Where most observability tools use an SDK-first model that requires you to manually wrap every LLM call and maintain that instrumentation as APIs evolve, Helicone asks only that you point your existing OpenAI, Anthropic or other API calls at its gateway by changing the base URL. That is the entire integration — no SDK wrapping, no decorator injection, no framework dependency — and it means a team can go from “we want visibility” to “we have visibility” in minutes rather than a sprint. That minimal friction is more than a convenience: as one analysis put it, adoption friction is the primary reason teams ship without observability at all, so a proxy that removes it is a strategic advantage. From that proxy foundation Helicone built two complementary layers. The observability layer logs the full request and response for every call, tracks tokens, cost and latency, supports user-level analytics and session tracing for debugging multi-step workflows, and surfaces it all in dashboards with custom filters. The gateway layer — the Helicone AI Gateway, built in Rust and launched in public beta in June 2025 — turned the proxy into a control plane, adding intelligent cost-based routing, automatic multi-provider fallbacks, response caching, load balancing and rate limiting behind a single OpenAI-compatible endpoint. Licensed under Apache 2.0 and fully self-hostable, Helicone became a favourite of AI-native startups building their observability stack from scratch. Within this site’s Machine Learning & MLOps category, Helicone occupies the proxy-first, gateway-plus-observability niche — the low-friction alternative to SDK-first platforms like Langfuse and LangSmith. The essential context for any 2026 reader, though, is that Mintlify’s March 2026 acquisition moved Helicone into maintenance mode: the sections below describe a genuinely excellent product that is still usable and self-hostable, but no longer actively evolving.
Core Features
Proxy-first observability and one-line integration
Helicone’s signature feature is the observability it delivers through its proxy, and the near-zero effort required to switch it on. Integration is famously a one-line change: you update the base URL your OpenAI or Anthropic (or other provider) client points at, add your Helicone API key, and every request from then on is automatically logged. Because it works at the HTTP layer with any OpenAI-compatible client, it needs no SDK wrapping and imposes minimal overhead — Helicone claims under one millisecond of added latency in self-hosted mode. Once traffic flows through the proxy, Helicone captures every call with full context: the complete prompt and completion, token counts, cost, latency and errors, giving you complete audit trails. On top of that raw data it provides distributed tracing for complex multi-model workflows (parent/child session paths let you represent hierarchical agent traces), user-level cost tracking suitable for chargeback and per-customer unit-economics analysis, and real-time dashboards with custom filters for cost, latency and error analysis. Custom properties and metadata — attached via simple headers — let you segment analytics by environment, feature, user or any dimension you choose, and webhook integrations enable automated alerting when thresholds are breached. It also maintains one of the most useful open assets in the space: an open-source LLM cost database covering pricing for 300-plus models and providers, which underpins accurate cost calculation and is queryable independently. This proxy-first design is Helicone’s greatest strength and, in normal circumstances, its clearest differentiator: for the majority of production needs — cost visibility, error-rate monitoring, latency SLOs and prompt-regression tracking — it delivers comprehensive observability with the least possible adoption friction. The one architectural trade-off, independent of the acquisition, is that a proxy sits in your request path, which some teams prefer to avoid; self-hosting mitigates the data-residency dimension of that concern but keeps the proxy dependency.
The AI Gateway: routing, caching and reliability
What elevated Helicone from a logging tool to a control plane was the Helicone AI Gateway, and it remains the platform’s most distinctive capability. Built in Rust for performance and launched in public beta in June 2025, the gateway provides access to more than 100 LLM providers and models through a single OpenAI-compatible endpoint — so an application can target many providers with one API key and one integration. On top of that unified access it layers genuine reliability and cost-optimisation features that most pure-observability tools treat as a separate product, if they offer them at all. Intelligent, cost-based routing automatically selects the cheapest available provider for a given model, with a bring-your-own-key priority that uses your existing cloud credits (AWS Bedrock, Azure and others) first; smart fallbacks reroute to the next-cheapest option if a provider fails or hits a rate limit; and response caching reduces both cost and latency by reusing stored responses for identical requests (independent estimates put typical savings at 20–40% for repetitive enterprise workloads). Rate limiting, load balancing and configurable retries with exponential backoff round out the reliability toolkit, all controllable through simple headers or configuration rather than bespoke code. The strategic point is that this makes Helicone a functional LLM gateway and observability platform in one integration — a combination that, as several comparisons note, differentiates it from pure-observability peers like Langfuse and Traceloop, and positions it alongside gateway-oriented tools like Portkey and LiteLLM. For teams that want routing, caching and rate limiting bundled with their observability rather than assembled from separate tools, this native combination was Helicone’s biggest draw. The caveat, again, is roadmap: in maintenance mode the gateway will receive bug fixes and new-model support but not new capabilities, so its feature set is effectively frozen at its March 2026 state.
Prompt management, evaluation, and open-source self-hosting
Beyond observability and the gateway, Helicone offered a rounded set of LLMOps features, though these were always secondary to its proxy-and-gateway core. Prompt management let teams version prompts using production data and deploy them through the AI Gateway without code changes, keeping prompts under the team’s control and always accessible. A playground allowed rapid testing and iteration on prompts, sessions and traces directly in the UI. A testing-and-experimentation framework supported running experiments and evaluating different prompts or models against production data, including LLM-as-a-judge evaluators — although it’s worth noting that the prompt A/B-testing “Experiments” feature was reported as deprecated, and Helicone’s evaluation depth was always lighter than dedicated evaluation-first platforms. There was also a fine-tuning path via partners (OpenPipe, Autonomi). The feature that matters most in light of the acquisition, though, is Helicone’s openness. The platform is licensed under Apache 2.0 — a permissive licence chosen deliberately, the founders said, for business-model transparency and to encourage enterprise adoption without licence-compatibility concerns — and it can be fully self-hosted via Docker and Helm (Kubernetes). This is the crucial mitigant to the maintenance-mode news: because the code is open and self-hostable, enterprises that cannot route model traffic through a third-party SaaS can run the entire gateway themselves and own the audit trail end-to-end, and any team can continue operating Helicone indefinitely on its own infrastructure, independent of Mintlify’s cloud roadmap. The self-hosted path removes the data-residency concern and eliminates per-request SaaS costs beyond infrastructure. It’s SOC 2 and GDPR compliant, with audit logs and data-retention policies to support compliance, and offers a generous free cloud tier for those who prefer managed hosting. In short, Helicone pairs a strong, well-architected core with genuine openness — which is exactly why, even in maintenance mode, it remains a viable self-hosted option for teams willing to own it, even as its cloud future points toward migration.
Scored Categories
These scores reflect Helicone’s genuine architectural quality, weighted heavily by the decisive reality that the product is in maintenance mode and no longer actively developed — the key consideration for anyone adopting it today.
Pricing
| Tier | Price | Notes |
|---|---|---|
| Self-hosted (open source) | Free (Apache 2.0) | Full platform via Docker/Helm; own your infrastructure and audit trail; no per-request cost beyond infra |
| Hobby (cloud) | $0 | 10,000 requests/month, dashboard, community support; no credit card; ~7-day retention |
| Pro (cloud) | from ~$20 / seat / month | Scales beyond 10k requests, core observability features, standard support (some sources cite higher full-feature tiers) |
| Team / Enterprise | Higher / custom | Longer retention, advanced features, SOC 2 & GDPR; startup & open-source discounts historically offered |
Strengths
- Lowest integration friction in the category — one-line base-URL change, no SDK
- Combined AI gateway + observability in a single integration (rare)
- 100+ models via one OpenAI-compatible endpoint; Rust-built gateway
- Cost-based routing, smart fallbacks, caching (20–40% typical savings), rate limiting
- Open-source (Apache 2.0) and fully self-hostable via Docker/Helm
- Full request/response logging, cost/latency/error tracking, session tracing
- User-level analytics & chargeback; open cost DB (300+ models)
- SOC 2 & GDPR compliant; generous free tier; sub-1ms proxy overhead (self-hosted)
- Proven at scale: 16,000+ orgs, 14.2T+ tokens over three years
Weaknesses / Cautions
- Maintenance mode since Mintlify’s March 2026 acquisition — no new features
- Cloud customers encouraged to plan migration; no active roadmap
- Risky as a new production dependency in a fast-moving ecosystem
- Proxy sits in your request path (a single point of failure to plan for)
- Evaluation depth lighter than eval-first tools; “Experiments” A/B feature deprecated
- No GPU/infrastructure-level metrics (unlike W&B Weave, OpenLIT)
- Free-tier retention short (~7 days); Hobby→Pro jump can be steep
- Self-hosting shifts the maintenance burden onto your team
Verdict: 6.8 / 10 — Brilliant Architecture, Now Frozen in Maintenance Mode
Helicone earns a 6.8 — a score that reflects real tension between how good the product is and where it now stands. On architecture and instinct, Helicone is excellent: its proxy-first, one-line integration is the lowest-friction way to add observability of any tool in the category; its combination of a genuine AI gateway (cost-based routing, fallbacks, caching, rate limiting across 100-plus models) with full observability in a single integration is rare and genuinely useful; and its Apache 2.0 licence with fully-supported self-hosting gives teams real openness and control. Proven across 16,000-plus organisations and 14.2 trillion tokens, it was, and in many respects still is, one of the best-designed products in LLM observability. But a 2026 review must serve the reader deciding today, and the decisive fact is that Mintlify’s March 2026 acquisition moved Helicone into maintenance mode: the services remain live and the open-source code still receives security patches, bug fixes and new-model support, but active feature development has ended and cloud customers are being guided toward migration. In a fast-moving ecosystem, a frozen roadmap is a serious mark against adopting the cloud product as a new production dependency — which is why the score sits well below the actively-developed leaders (Langfuse and LangSmith at 8.5, Arize at 8.4) despite Helicone’s architectural quality. It sits well above fully shut-down tools, however, precisely because Helicone is not dead: it’s still live, and — critically — it’s open-source and self-hostable indefinitely, so a team that specifically wants its proxy-and-gateway model can capture that value by self-hosting and owning the maintenance burden. The clean verdict: admire Helicone’s design, and consider self-hosting it if its combined gateway-plus-observability proxy is exactly what you need and you’re prepared to own it; but for a new, actively-supported managed dependency, choose one of the still-expanding alternatives below. Existing users have no urgent shutdown to fear, but should begin planning migration on their own timeline.
Frequently Asked Questions
What happened to Helicone — is it still available?
Yes, Helicone is still available and running, but its status changed meaningfully in 2026. On 3 March 2026, Mintlify — a documentation-tooling company that had itself been using Helicone’s gateway and observability internally — announced it was acquiring Helicone, and the founders, Justin Torre and Cole Gottdank, joined Mintlify in San Francisco to work on AI knowledge infrastructure. Following the acquisition, the Helicone product entered maintenance mode. Importantly, that is not the same as a shutdown: Mintlify and the Helicone team have both stated that Helicone’s services remain live for the foreseeable future, with security updates, bug and performance fixes, and new-model support continuing to ship. What has stopped is active feature development — there is no new roadmap, no new integrations or analytics coming — and Mintlify has said it will support customers through migration to alternative platforms. So the practical picture is nuanced. The proxy still works, the cloud service is still up, the GitHub repository (Apache 2.0) still accepts contributions, and the Docker image is current, so there’s no immediate cliff-edge for existing users. But the product is effectively frozen at its early-2026 feature set, and for a category evolving as fast as LLM observability, a maintenance-mode tool falls behind an actively-developed one over time. The single most important consequence is for the open-source self-hosting path: because Helicone is Apache 2.0 licensed and fully self-hostable via Docker and Helm, any team can continue running it on its own infrastructure indefinitely, independent of Mintlify’s cloud decisions — which is the durable way to keep using Helicone if you value it. For new adopters relying on the managed cloud, the guidance is to treat Helicone as a solution for present needs rather than a long-term strategic bet, and to have a migration plan.
Should I still adopt Helicone in 2026?
It depends heavily on how you’d deploy it and how much you value its specific architecture. There’s a reasonable case for adopting Helicone in one particular scenario: you specifically want its combination of a proxy-based LLM gateway (cost-based routing, multi-provider fallbacks, caching, rate limiting across 100-plus models) with observability in a single integration, you want the openness and control of an Apache 2.0 self-hosted deployment, and your team is prepared to own the maintenance burden of running it. In that case Helicone’s excellent architecture, sub-millisecond self-hosted overhead and full data ownership are genuinely attractive, and because you control the code, the maintenance-mode status of the cloud product matters far less to you — you’re not dependent on the vendor’s roadmap. The case weakens sharply, however, for the more common scenario of adopting the managed cloud service as a new production dependency. Building a fresh, business-critical integration on a platform whose vendor has stopped feature development and is actively guiding customers toward migration is a risk: as the ecosystem evolves — new models, new providers, new capabilities — a frozen tool falls progressively behind, and provider API changes may not get fast fixes. For greenfield projects starting today, actively-maintained alternatives are the more defensible choice. There’s also an architectural consideration independent of the acquisition: Helicone’s proxy sits in your request path, which is a single point of failure some teams prefer to avoid (self-hosting addresses data residency but keeps the proxy dependency). The balanced guidance: if you want Helicone’s proxy-plus-gateway model, self-host it and own it; if you want a managed, actively-developed service with a roadmap you can rely on for years, choose an alternative that is still expanding. And if you’re an existing Helicone user, there’s no need to panic-migrate — the service is stable — but you should start planning a migration on your own timeline rather than waiting for circumstances to force it.
What are the best alternatives to Helicone?
The strongest alternatives depend on which part of Helicone mattered to you, and encouragingly the category is full of actively-developed options. If you valued Helicone’s open-source, self-hostable nature and want a broad, actively-developed LLM engineering platform, Langfuse is the standout choice and the most commonly cited migration target — it’s open-source (MIT), OpenTelemetry-native, framework-agnostic, and offers tracing, prompt management, evaluations and analytics in one platform, with an official Helicone-to-Langfuse migration guide and per-team pricing that scales well. If your priority is standards-based observability with a genuinely free self-hostable core and deep ML heritage, Arize AI’s Phoenix is an excellent OpenTelemetry-native option. If you’re building on LangChain or LangGraph, or you want the most mature evaluation tooling and a complete observe-to-deploy stack, LangSmith is the category’s proprietary leader. And if you want a broad platform that unifies experiment tracking with LLM observability and evaluation, Comet (with its open-source Opik project) is a strong, actively-developed choice. For Helicone’s specific gateway function — unified multi-provider routing, caching and fallbacks — the closest actively-developed peers are gateway-oriented tools like Portkey and LiteLLM, which many teams pair with a separate observability platform. And if your real need was primarily cost visibility rather than deep tracing, lightweight cost-monitoring tools that use read-only provider keys (avoiding a proxy in your request path entirely) can be a simpler drop-in. The rough decision guide: choose Langfuse or Arize Phoenix for open-source, OpenTelemetry-native, self-hostable observability; LangSmith for the deepest evaluation and LangChain integration; Comet for unified ML-and-LLM breadth; and a dedicated gateway (Portkey, LiteLLM) plus a separate observability tool if the AI-gateway routing function was Helicone’s main draw. All of these are on an active development trajectory, which is the decisive advantage over a maintenance-mode product — though if you self-host Helicone under Apache 2.0, you can also simply keep running it while you evaluate.