Skip to content

Migration guidesFrom Helicone

Moving off Helicone, without pretending it is simple

Helicone has been acquired by Mintlify and its services are in maintenance mode. If you are deciding where to go, this page is the concept-by-concept map: what your code has to become, what INFRO does that Helicone did not, the four things INFRO simply does not have — and the section most of these pages leave out, which is when somebody else is the better answer.

INFRO is in private early access. The catalog, the docs, and the API contract are public today, and the gateway is deployed. The console opens with an early-access account, billing opens in stages, and anything beyond v1 is marked Later. Early access details

Where things stand

What was announced

Helicone has been acquired by Mintlify. Helicone's own post says its services “will remain live for the foreseeable future in maintenance mode”, with security updates, new models, and bug and performance fixes still shipping. Mintlify's post says the same and adds that they will “work closely with every customer to support a smooth migration to another platform”.

What was not announced

Neither post gives a shutdown date, a data-retention commitment, or a plan for the open-source repository. Read that as it is written: maintenance mode is not an outage, and nothing here needs doing this week. It is a reason to decide deliberately rather than to hurry.

Why this page exists at all

Because the honest answer depends on what you were using Helicone for, and most of the pages you will find on this search are not going to tell you that. If you were there for tracing, evaluations, and prompt management, the next section names a better destination than us.

This section is above the differences on purpose. A large share of the people reading this were using Helicone as an observability and evaluation platform, and for that job there is a product built squarely around it.

Langfuse describes itself as an open-source AI engineering platform for agent evaluation and observability: hierarchical tracing across LLM calls, tool invocations and retrieval steps, LLM-as-a-judge and heuristic evaluators, prompt management with deployment and rollback, datasets and experiments, human annotation, and a playground. It is MIT-licensed with self-hosting on Docker Compose, Kubernetes and Terraform, and it was acquired by ClickHouse in January 2026 — which, on ClickHouse's own account, leaves it open source and self-hostable with the cloud service running as before.

The reason to look at INFRO is a different problem wearing similar clothes. If what you actually have is several provider accounts across several teams, spend nobody can attribute until the invoice lands, retries and fallbacks written differently in each codebase, and no approval step for which model a service may call — that is a control-plane problem, not an observability one, and it is the problem this product is built around. Plenty of teams need both, and running INFRO as the gateway with tracing exported to a collector of your choice is a reasonable shape.

Choose Langfuse when

  • You were at Helicone primarily for observability. Langfuse is that product, built deliberately and at depth, and it is the closest thing to a like-for-like destination that exists.
  • You need prompt management or evaluators. INFRO has neither, and no date for either. Langfuse has both, and evaluation is one of the two things it leads with.
  • You trace agents, not just model calls. Langfuse models a trace tree spanning tool calls and retrieval steps. INFRO records one request at a time; a span tree is something you assemble in your own collector.
  • You want to self-host without a sales conversation, or keep that option open. Langfuse is MIT-licensed and anyone can run it. INFRO's plans are hosted; it runs in your own infrastructure only under an enterprise agreement.
  • You want it working today with a credit card. Langfuse cloud is self-serve; INFRO's self-serve sign-up is not open yet.

Langfuse is not a partner, a reseller, or an affiliate of INFRO. We link it because it is the honest answer to a question this page would otherwise be answering dishonestly.

Helicone's objects against ours, read from their public documentation on 20 September 2026 and checked against what the gateway actually implements. Four rows say we have nothing; those are the ones worth reading first.

HeliconeWhat it does thereIn INFRO
Gateway integrationsame shapePoint an OpenAI-compatible client at Helicone's AI gateway base URL and pass your Helicone key.The same shape: base URL https://api.infro.io/v1, key in Authorization: Bearer. Two lines, one per service.
Async logging, off the request pathnothingAn OpenLLMetry-based logger wraps your provider SDK so Helicone is not in your application's critical path.Nothing equivalent. INFRO is a gateway, so it is always on the path — that is what lets it route, fail over, and refuse a request against a budget, and it is a real trade you are making.
Whose provider account serves the requestdifferentThe gateway can supply model access, and Helicone also supports bringing your own provider keys.Only your own. You connect provider accounts you already hold, your providers invoice you directly at your own rates, and INFRO takes 0% of model spend.
Custom propertiesdifferentArbitrary tags sent as Helicone-Property-<Name> request headers, used for filtering and cost analysis.A metadata object in the request body, filterable on the request log as tag.<key>. Same idea, different place — a header becomes a body field, which is the largest single edit in the port.
End-user trackingdifferentHelicone-User-Id identifies an end user, with per-user engagement, retention and satisfaction analytics built on it.metadata.user_id is recorded on every request and filters the request log and usage grouping, so cost per end user is answerable. There is no per-user behavioural analytics screen — no session length, return rate, or satisfaction scoring.
Sessions and trace treesdifferentHelicone-Session-Id, -Path and -Name group related calls into one view, including non-LLM steps such as vector queries and tool calls, with parent/child structure from the path.metadata.session_id groups requests in the log, and spans can be pushed to your own OpenTelemetry collector from the request path. What INFRO does not have is a session view with a trace tree in it: it records model calls, not the steps between them.
Response cachingdifferentHelicone-Cache-Enabled caches complete responses at the edge, with a bucket size and a cache seed.An exact-match response cache for chat completions, off by default and turned on per organization or project. An identical request inside the time-to-live is answered from the cache and never reaches your provider, so your provider does not bill it. Control is a cache body field or X-INFRO-Cache headers; a cache seed becomes X-INFRO-Cache-Namespace. There is no bucket of several stored answers and no semantic (similar-prompt) matching. The docs page is /docs/features/caching.
Custom rate limitsdifferentHelicone-RateLimit-Policy sets a quota per window, in requests or in cost, segmented globally, per user, or per custom property.Per-key request-rate tiers reported as X-RateLimit-Limit, plus budgets at the organization, project, member and key that refuse traffic at the ceiling with 402 budget_exceeded. Cost ceilings map well; a limit segmented by end user or by an arbitrary property does not.
Prompt managementnothingPrompts managed outside the codebase, with versions compared against production traffic.Nothing, and nothing planned that we will name. Prompts stay in your repository, or in a tool that does this properly — Langfuse does.
Evaluators and experimentsnothingLLM-as-a-judge and custom evaluators scoring output quality, with side-by-side prompt comparison. Helicone's docs carry a deprecation notice on the Experiments feature.Nothing. INFRO does not score model output and has no opinion about whether an answer was good.
WebhooksdifferentSigned webhooks fire on request completion, carrying request and response bodies, cost, tokens and latency.Signed webhooks, but for async media jobs only — job.succeeded, job.failed, job.canceled. There is no per-request completion hook; the request log and GET /v1/requests are how you read finished traffic.
Cost per requestdifferentCost computed per request and rolled up by property, user and model.An estimate of what your provider will bill, on the response as usage.cost, with usage.price_source saying whether it came from your negotiated rate, your rate for that model, or the vendor's list rate — and absent rather than guessed when no rate is known.
Fallbacks and multi-provider routingsame shapeProvider fallback through the gateway.Named routes with priority or weighted targets over your own connections. A target that times out or 5xxs before the response starts is retried elsewhere; once bytes are flowing the error surfaces rather than being re-routed.
Model policydifferentNot a documented Helicone concept in the pages we read; the nearest control is a rate limit.An allowlist at the organization, project or key. The narrowest scope wins and anything outside it is refused before it costs anything.
Historical datanothingRequests, properties, sessions and scores already in Helicone.No importer, and none planned. Nothing you logged there appears here. Export it from Helicone and keep it somewhere you control before you stop sending.
Open source and self-hostingdifferentHelicone's platform is open source and can be run yourself.The gateway is not open source. Its plans are hosted; a self-hosted or hybrid deployment comes only with an enterprise agreement. If you need to run it yourself without one, stop here.Enterprise — Available on an enterprise agreement rather than self-serve.

Our reading of Helicone’s published documentation, not a trial or a benchmark. Their docs moved during the transition and some feature pages no longer resolve where they used to; where we could not confirm something, the row says so rather than guessing. Every source and the date we opened it is listed at the foot of this page.

Two lines for the connection. The work is in the annotations: Helicone carries them as request headers, INFRO carries them in the request body, so anywhere you set a header there is an edit.

Before · Helicone gateway

import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://ai-gateway.helicone.ai",
  apiKey: process.env.HELICONE_API_KEY,
  defaultHeaders: {
    "Helicone-User-Id": "user_8f21",
    "Helicone-Session-Id": sessionId,
    "Helicone-Property-Feature": "summarizer",
  },
});

const completion = await client.chat.completions.create({
  model: "claude-opus-5",
  messages,
});

After · INFRO

import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.infro.io/v1",
  apiKey: process.env.INFRO_API_KEY,
});

const completion = await client.chat.completions.create({
  model: "anthropic/claude-opus-5",
  messages,
  // Annotations move from headers into the body. Recorded on the request,
  // never forwarded upstream, and ignored by any OpenAI-compatible backend
  // that does not know the field — so the same call still runs elsewhere.
  metadata: {
    user_id: "user_8f21",
    session_id: sessionId,
  },
});

The base URL and the key

https://api.infro.io/v1, with the key in the standard Authorization: Bearer header — so it is the baseURL and apiKey arguments your client already has. If your code still points at Helicone's older per-provider proxy host and carries a separate Helicone-Auth header, that header comes out entirely; INFRO does not use one.

The model id

Models are addressed as vendor/model, for example anthropic/claude-opus-5. GET /v1/models lists what your key can actually call, which is whatever your own connected provider accounts serve — a model no connection covers returns 503 no_provider_connected naming the provider to connect.

The annotations

Helicone-User-Id becomes metadata.user_id, Helicone-Session-Id becomes metadata.session_id, and every Helicone-Property-X becomes a key under metadata.tags, filtered on the request log as tag.x. In TypeScript, OpenAI's own metadata type is a flat string map, so the nested tags object needs a cast; Python's extra_body takes it as written.

One thing worth trying before you commit: Helicone's async integration wraps your provider client rather than sitting on the network path, so in principle it keeps logging while the base URL points here. We have not tested that combination and cannot promise it — run it on one service first, and read GET /v1/requests on this side to check both agree about what happened.

Four things, all of which follow from being a gateway that runs on your own provider accounts rather than a logger that watches them.

The account that served the request is yours, and it is named
Every response carries provider — the provider kind whose account ran it — and connection, the id of the connection it used, alongside route and route_name when a route resolved it. There is no pool behind the gateway and no margin on the traffic: your provider invoices you at your own rates, and INFRO charges a subscription for the layer.
Cost is an estimate that says where it came from
usage.cost is an estimate of your provider's bill for that request, and usage.price_source says how it was reached — custom_provider for your negotiated rate on the provider that served it, custom for your rate for that model, list for the vendor's published rate. When no rate is known the request is recorded unpriced rather than as zero, because a zero in a cost column is a claim and an absence is a fact.
A budget can refuse a request
Ceilings at the organization, project, member and key, with alert thresholds you set. At the cap the gateway returns 402 budget_exceeded rather than emailing you about the overspend afterwards — which is the difference between a budget and a report.
The estimates are checked against the provider's own billing
A daily pass reads OpenAI's and Anthropic's cost APIs with a separate admin credential and stores the reported figure beside what INFRO estimated, so what you see is a variance rather than a number to take on trust. Only those two providers have an adapter; a provider without one shows no variance rather than a variance of zero, and Bedrock, Vertex and Azure keep their cost in the surrounding cloud's billing system.

What does not come across

There is no importer. Nothing you logged in Helicone appears in INFRO, and nothing here will reach back for it. Export what you need while their service is still up.

  • Your request history. There is no importer, and no plan for one. Export what you need from Helicone first; nothing in INFRO will reach back for it.
  • Custom properties, sessions and user ids already recorded. Annotations start from the first request you send here.
  • Cached responses. Entries in another product's cache do not move; INFRO's cache starts empty and fills from your own traffic, and it matches exact requests only, never similar ones.
  • Prompts and evaluator scores. There is nowhere for them to land.
  • A Helicone deployment you were running yourself. INFRO's plans are hosted; running INFRO in your own infrastructure is an enterprise agreement, not a migration step.

If the control plane is the part you want

Read the API contract first — it is published in full, including the parts that do not exist yet, so you can decide before writing anything. Then tell us what you are running and we will tell you honestly whether this is a move worth making.

Request a 14-day trial Read the docsCompare with the alternatives

Sources

Every statement on this page about Helicone or Langfuse comes from one of these, with the date we read it. Nothing is inferred from a trial, a benchmark, or a conversation.