# Helicone Alternatives After the Mintlify Acquisition Helicone joined Mintlify in 2026, and teams are rechecking their LLM observability options: Langfuse, Portkey, gateway built-in logs, and lightweight request logging. *Published 2026-06-12 ยท https://proxyllm.ai/blog/helicone-alternatives* Helicone joined Mintlify in 2026, and the question on the table for its users is ordinary and fair: where does LLM observability live if the roadmap drifts? The serious alternatives sort by depth. Langfuse for open-source traces, evals, and prompt management. Portkey for a gateway that bundles logging with guardrails. Built-in gateway logs, LiteLLM callbacks or your endpoint's own request log, when lightweight is the point. ProxyLLM appears in that last group, and it is our product, so weigh our take accordingly. ## What the acquisition changed The acquisition itself is the boring kind of news: a good team earned an exit, the hosted product kept running, and the open-source repo stayed public. Nobody's dashboards went dark. What changed is confidence in the roadmap, because Helicone's priorities now compete inside a company whose core business is documentation. That is a normal reason to survey the field; it is not a reason for fear, and Helicone may keep serving its users well for years. The useful exercise is naming what you actually used. Most teams bought an observability platform and used the request log. If that describes you, your replacement list is longer and cheaper than the feature matrix suggests. ## What you actually used Helicone for Helicone's appeal was the one-line setup: point your base URL at the proxy and get request logs, per-request cost, latency, and usage dashboards without touching application code. Sessions, caching, and prompt experiments sat on top for the teams that went deeper. So the replacement question splits in two. Teams that lived in traces and experiments need a real platform. Teams that needed "what did we spend, on what, through which key" need a good log, and good logs now come built into several things you might already run. ## Langfuse: the open-source depth pick Langfuse is the closest thing to a default successor: open source, self-hostable or cloud-hosted, with tracing for multi-step agent runs, evals, prompt management, and cost tracking. Integration is SDK-based rather than proxy-based, which means touching code but also capturing structure a proxy never sees, like which step of an agent loop burned the tokens. Where it wins: engineering teams that treat LLM behavior as something to test and version, and anyone with a self-host requirement. Where it costs you: instrumentation work, and operating the deployment if you self-host. ## Portkey: the gateway that bundles observability Portkey attacks the same need from the gateway side: requests route through it, so logs, traces, cost attribution, guardrails, and caching arrive as gateway features with SaaS pricing on top and your provider keys billing at cost underneath. For teams under governance pressure, logging plus guardrails in one control plane is the draw. Where it wins: organizations that wanted Helicone plus policy enforcement. Where it costs you: another vendor in the request path, and platform ceremony if all you wanted was the log. The job-by-job breakdown is in [Portkey alternatives](/blog/portkey-alternatives). ## Built-in gateway logs If a gateway already fronts your traffic, check what it logs before adding a vendor. LiteLLM ships logging callbacks and per-key spend tracking in the self-hosted router. OpenRouter's activity page gives per-request history for marketplace traffic. These are not tracing platforms, and they answer the spend-and-usage questions at zero added integration cost. Our survey of the gateway field itself is in [OpenRouter alternatives](/blog/openrouter-alternatives). ProxyLLM sits in this category, and the disclosure again: it is our product. Every request through our endpoint is logged with the model, the lane that served it (Codex flat lane, second account, or your API key), latency, and its API-equivalent dollar value, with per-key logs when you issue scoped sub-keys. The log exists on the $0 Starter tier with bring-your-own keys. The honest scope statement: this is a request log, deliberately. There are no traces, evals, or prompt versioning, and teams that need those should buy Langfuse or Portkey without hesitating. ## The comparison table | Tool | Integration | Hosting | Depth | Price shape | Pick when | | --------------------- | ----------------------- | -------------------- | --------------------------- | -------------------------- | -------------------------------- | | Helicone (status quo) | Proxy, base URL change | Hosted; OSS repo | Logs, sessions, experiments | Free tier + SaaS | It still fits; watch the roadmap | | Langfuse | SDK instrumentation | Self-host or cloud | Traces, evals, prompt mgmt | OSS free; cloud plans | Depth and self-hosting matter | | Portkey | Gateway in request path | Hosted; OSS core | Logs, traces, guardrails | SaaS plans | Governance plus observability | | LiteLLM callbacks | Config on your router | Self-host | Logs, per-key spend | Free OSS + your infra | You already run LiteLLM | | ProxyLLM request log | Built into the endpoint | Hosted (our product) | Per-request log, lane, cost | $0 tier; $129/mo flat lane | Lightweight cost visibility | ## How to choose Start from the question you ask most. If it is "why did the agent do that," buy tracing: Langfuse. If it is "log it and police it," Portkey. If it is "what did this key spend yesterday," a built-in log answers it for free, ours included. A log you actually check beats a tracing suite you configured once and abandoned. There is also a cost angle observability never fixes on its own: perfect visibility into a metered bill still leaves the meter running. The wider tooling picture, cost models included, is in [the best LLM gateways in 2026](/blog/best-llm-gateway-2026). If lightweight logging plus a flat-cost OpenAI lane sounds like your shape, the [Starter tier](/) is $0 and takes minutes to point a base URL at.