Helicone

Proxy mode
AI Gateway

# Before
from openai import OpenAI
import os

client = OpenAI(
    base_url="https://oai.helicone.ai/v1",
    api_key=os.environ["OPENAI_API_KEY"],
    default_headers={
        "Helicone-Auth": f"Bearer {os.environ['HELICONE_API_KEY']}",
    },
)

# After
from openai import OpenAI
import os

client = OpenAI(
    base_url="https://api.concentrate.ai/v1",
    api_key=os.environ["CONCENTRATE_API_KEY"],
)

// Before
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://oai.helicone.ai/v1",
  apiKey: process.env.OPENAI_API_KEY,
  defaultHeaders: {
    "Helicone-Auth": `Bearer ${process.env.HELICONE_API_KEY}`,
  },
});

// After
const client = new OpenAI({
  baseURL: "https://api.concentrate.ai/v1",
  apiKey: process.env.CONCENTRATE_API_KEY,
});

# Before
curl https://oai.helicone.ai/v1/chat/completions \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Helicone-Auth: Bearer $HELICONE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{ "model": "gpt-4o", "messages": [...] }'

# After
curl https://api.concentrate.ai/v1/chat/completions \
  -H "Authorization: Bearer $CONCENTRATE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{ "model": "gpt-4o", "messages": [...] }'

# Before
from openai import OpenAI
import os

client = OpenAI(
    base_url="https://ai-gateway.helicone.ai",
    api_key=os.environ["HELICONE_API_KEY"],
)

# After
from openai import OpenAI
import os

client = OpenAI(
    base_url="https://api.concentrate.ai/v1",
    api_key=os.environ["CONCENTRATE_API_KEY"],
)

// Before
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://ai-gateway.helicone.ai",
  apiKey: process.env.HELICONE_API_KEY,
});

// After
const client = new OpenAI({
  baseURL: "https://api.concentrate.ai/v1",
  apiKey: process.env.CONCENTRATE_API_KEY,
});

# Before
curl https://ai-gateway.helicone.ai/chat/completions \
  -H "Authorization: Bearer $HELICONE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{ "model": "anthropic/claude-opus-4-6", "messages": [...] }'

# After
curl https://api.concentrate.ai/v1/chat/completions \
  -H "Authorization: Bearer $CONCENTRATE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{ "model": "anthropic/claude-opus-4-6", "messages": [...] }'

Prerequisites

A Concentrate AI account with an active API key

An existing Helicone integration

This guide assumes you are calling Helicone from the OpenAI SDK, fetch, requests, or another HTTP client (in proxy or AI Gateway mode).

Quick Start for Claude Code users

If you use Claude Code, you can install a skill that walks through this migration interactively. It searches your project for Helicone usage, strips Helicone-* headers, maps model slugs, and generates a verification script. Drop the skill into your ~/.claude/skills/ directory:

mkdir -p ~/.claude/skills/migrate-helicone && \
  curl -fsSL https://concentrate.ai/scripts/migrate-helicone.md \
  -o ~/.claude/skills/migrate-helicone/SKILL.md

Then start a Claude Code session in your project and ask it to “migrate from Helicone to Concentrate” or run /migrate-helicone. Claude will load the skill and run the steps.

Step 1: Update Your Environment Variables

Replace your Helicone and (in proxy mode) provider keys with a single Concentrate key:

# Before (proxy mode)
export OPENAI_API_KEY="sk-..."
export HELICONE_API_KEY="sk-helicone-..."
export BASE_URL="https://oai.helicone.ai/v1"

# After
export CONCENTRATE_API_KEY="sk-cn-v1-..."
export BASE_URL="https://api.concentrate.ai/v1"

In provider-proxy mode you no longer need OPENAI_API_KEY, ANTHROPIC_API_KEY, or any other upstream provider key. Concentrate owns those credentials. Comment them out (don’t delete) until you’ve verified the migration end-to-end, then remove them.

If you were on Helicone’s AI Gateway, you weren’t carrying provider keys to begin with. The env-var change is just the URL and the API key.

Step 2: Update Your Client

The two big changes are the base URL and stripping every Helicone-* header.

# Before (Helicone proxy)
from openai import OpenAI
import os

client = OpenAI(
    base_url="https://oai.helicone.ai/v1",
    api_key=os.environ["OPENAI_API_KEY"],
    default_headers={
        "Helicone-Auth": f"Bearer {os.environ['HELICONE_API_KEY']}",
        "Helicone-User-Id": "user_42",
        "Helicone-Property-Feature": "summarizer",
        "Helicone-Cache-Enabled": "true",
    },
)

# After (Concentrate)
from openai import OpenAI
import os

client = OpenAI(
    base_url="https://api.concentrate.ai/v1",
    api_key=os.environ["CONCENTRATE_API_KEY"],
)

response = client.chat.completions.create(
    model="anthropic/claude-opus-4-6",
    messages=[{"role": "user", "content": "Say hello in one word"}],
)
print(response.choices[0].message.content)

// Before (Helicone proxy)
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://oai.helicone.ai/v1",
  apiKey: process.env.OPENAI_API_KEY,
  defaultHeaders: {
    "Helicone-Auth": `Bearer ${process.env.HELICONE_API_KEY}`,
    "Helicone-User-Id": "user_42",
    "Helicone-Property-Feature": "summarizer",
  },
});

// After (Concentrate)
const client = new OpenAI({
  baseURL: "https://api.concentrate.ai/v1",
  apiKey: process.env.CONCENTRATE_API_KEY,
});

const response = await client.chat.completions.create({
  model: "anthropic/claude-opus-4-6",
  messages: [{ role: "user", content: "Say hello in one word" }],
});
console.log(response.choices[0].message.content);

curl https://api.concentrate.ai/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $CONCENTRATE_API_KEY" \
  -d '{
    "model": "anthropic/claude-opus-4-6",
    "messages": [{"role": "user", "content": "Say hello in one word"}]
  }'

Step 3: Remove `Helicone-*` Headers

None of Helicone’s custom headers carry over to Concentrate, so they should come out. They’re dead weight in your client config and mislead future readers. Expand the tables below for the full mapping if any of these are in your code.

Request header mapping

Helicone header	Concentrate replacement
`Helicone-Auth`	Standard `Authorization: Bearer sk-cn-v1-...`.
`Helicone-Target-URL`, `Helicone-OpenAI-Api-Base`	Not needed. Concentrate routes by model slug, not by target URL.
`Helicone-User-Id`	Issue per-user (or per-team / per-organization) keys. Cumulative analytics roll up automatically under whichever key, team, or org the request was made with. No per-request tagging required.
`Helicone-Session-Id`, `Helicone-Session-Path`, `Helicone-Session-Name`	Use `previous_response_id` on the Responses API to build a stateful tree of related requests.
`Helicone-Property-[Name]`	No equivalent today.
`Helicone-Prompt-Id`	No equivalent today; on the roadmap.
`Helicone-Model-Override`	Not needed. Concentrate computes cost from the resolved model on every request.
`Helicone-Fallbacks`	`routing.model.fallbacks` / `routing.provider.fallbacks` body params, or `model: "auto"` with a routing strategy.
`Helicone-Cache-Enabled`, `Cache-Control`	Provider-native prompt caching on Anthropic + AWS Bedrock, with Anthropic’s TTL options (`5m` / `1h`).
`Helicone-Cache-Seed`	The cache is automatically seeded per API key. To set the seed explicitly, pass `prompt_cache_key` in the request body.
`Helicone-Cache-Bucket-Max-Size`	Not applicable. Concentrate does not store cached responses at the gateway; caching is delegated to the provider.
`Helicone-Retry-Enabled`, `helicone-retry-num`, `helicone-retry-factor`, `helicone-retry-min-timeout`, `helicone-retry-max-timeout`	Automatic failover on any provider error across your fallback chain, plus the 90% per-feature uptime gate.
`Helicone-RateLimit-Policy`	Per-key rate and spend limits in the dashboard.
`Helicone-Token-Limit-Exception-Handler` (`truncate`, `middle-out`, `fallback`)	Handle in application code, or rely on auto-routing to pick a model with sufficient context.
`Helicone-Moderations-Enabled`, `Helicone-LLM-Security-Enabled`	Guardrails & Redaction. For content moderation use cases not covered by Guardrails, call the provider’s moderation endpoint directly.
`Helicone-Omit-Request`, `Helicone-Omit-Response`	Disable Request Logging at the key or org level. See Zero Data Retention & Logging.
`Helicone-Posthog-Key`, `Helicone-Posthog-Host`	Not built in. Export from the Concentrate dashboard or pull from request logs if you need PostHog ingest.
`Helicone-Stream-Force-Format`	Not needed. Concentrate emits canonical OpenAI / Responses SSE for every provider.
`Helicone-Request-Id`	Supply your own `X-Request-Id` if you want correlation; Concentrate also returns its own request id on the response.

Response header mapping

Helicone echoes a handful of Helicone-* headers back on every response. If your code reads or logs them, here’s the mapping:

Helicone response header	Concentrate equivalent
`Helicone-Id`	`X-Request-Id` (Concentrate’s per-request id, surfaced in dashboard logs)
`Helicone-Cache` (`HIT` / `MISS`)	Cache status is reported in the dashboard and (where supported) in the response body’s `usage.prompt_tokens_details.cached_tokens` field. Not a response header
`Helicone-Cache-Bucket-Idx`	No equivalent. Concentrate does not bucket cached responses at the proxy
`Helicone-Fallback-Index`	No header equivalent. The resolved provider is recorded per request in the dashboard
`Helicone-RateLimit-Limit`, `Helicone-RateLimit-Remaining`, `Helicone-RateLimit-Policy`	Standard `X-RateLimit-*` headers; see Errors for 429 semantics

If you have alerting wired to Helicone-Cache: MISS or Helicone-Fallback-Index, those signals are not on the response path in Concentrate. Replace them with dashboard-based alerts.

Step 4: Update Model Identifiers

Concentrate accepts model strings in two forms:

Bare slug, e.g. gpt-4o, claude-haiku-4-5, auto. Routing picks a provider.
provider/model-id, e.g. bedrock/claude-haiku-4-5, openai/gpt-4o. Pins the request to a specific provider.

If you were on Helicone’s provider-proxy mode with bare slugs, they work as-is. If you were on Helicone’s AI Gateway with author/model-id strings, most will still resolve, but be aware of how the slug is interpreted. One thing to know about the slashed form: the prefix is the provider that serves the request, not the model’s author. Helicone’s AI Gateway uses the model’s author in the slug; Concentrate uses the provider. For most popular names the two are the same string (openai, anthropic, mistral, cohere). They diverge whenever a model is hosted by something other than its author:

Author	Provider serving the request	Concentrate slug
Anthropic (`claude-haiku-4-5`)	Anthropic	`anthropic/claude-haiku-4-5`
Anthropic (same model, different host)	AWS Bedrock	`bedrock/claude-haiku-4-5`
Anthropic (same model, different host)	Azure	`azure/claude-haiku-4-5`
Google (`gemini-3.5-flash`)	Google AI Studio	`ai-studio/gemini-3.5-flash`
Meta (`llama-3-8b-instruct`)	AWS Bedrock	`bedrock/llama-3-8b-instruct`

Bare slugs work in all of these cases. Use them when you don’t care which provider serves the request. Use the provider/ prefix when you specifically want to pin to one host (for ZDR compliance, contractual reasons, or latency in a specific region). The only universally required slug change vs. Helicone’s AI Gateway is auto-routing:

Helicone AI Gateway	Concentrate AI
`auto` (Helicone’s optimizer)	`auto` with explicit `routing.model.sort` (`cost` / `latency` / `performance`)

For the authoritative list of supported provider/model-id pairs, call GET /v1/models or browse the Model Fortress.

Step 5: Reconnect Observability

Concentrate’s dashboard covers the major surfaces you used in Helicone.

Helicone dashboard surface	Concentrate equivalent
Requests log	Per-request logs at concentrate.ai
Users / User-Id breakdown	Per-user / team / organization keys. Analytics roll up by whichever key, team, or org the request was made with
Properties drilldown	No equivalent today
Sessions trace view	`previous_response_id` on the Responses API links related requests into a stateful tree
Cache hit rate	Reported per request where the provider supports caching
Cost dashboard	Org / team / developer / key spend rollup
Rate-limit policies	Per-key rate and spend limits

Exporting your Helicone history

Helicone’s dashboards do not import into Concentrate, and the reverse is also true. Historical request logs stay where they were created. If your migration is driven by compliance or audit requirements, Helicone exposes a logs export via their API; pull your history out before deprovisioning your Helicone account.

Step 6 (Optional): Adopt the Responses API

For new code, we recommend the native Responses API. It supports streaming, tool calling, structured output, multi-modal input, and web search through a single normalized shape across every provider.

curl https://api.concentrate.ai/v1/responses \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $CONCENTRATE_API_KEY" \
  -d '{
    "model": "anthropic/claude-opus-4-6",
    "input": "What is the capital of France?"
  }'

import os
import requests

response = requests.post(
    "https://api.concentrate.ai/v1/responses",
    headers={
        "Authorization": f"Bearer {os.environ['CONCENTRATE_API_KEY']}",
        "Content-Type": "application/json",
    },
    json={
        "model": "anthropic/claude-opus-4-6",
        "input": "What is the capital of France?",
    },
)
print(response.json())

const response = await fetch("https://api.concentrate.ai/v1/responses", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.CONCENTRATE_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    model: "anthropic/claude-opus-4-6",
    input: "What is the capital of France?",
  }),
});
console.log(await response.json());

Why migrate to Concentrate

How it works

Helicone offers two integration shapes you might be using today. The migration path is different for each:

Provider-proxy mode. Point the OpenAI SDK at https://oai.helicone.ai/v1, anthropic.helicone.ai, groq.helicone.ai, etc., keep using your own provider API key, and send Helicone-Auth: Bearer sk-helicone-... for logging. Migrating here gets you off provider keys entirely.
AI Gateway mode. Point at https://ai-gateway.helicone.ai with managed upstream credentials and consolidated billing. Migration here is a straight base-URL + key swap.

Team-scale spend management

Concentrate organizes billing around an organization → team → developer → key hierarchy. Set budgets at any level and roll spend up into a single dashboard. This is the structural difference from Helicone’s account model and matters most for organizations issuing keys to many internal teams or external developers.

Feature-aware resiliency

In addition to ordered model and provider fallbacks (routing.model.fallbacks, routing.provider.fallbacks), Concentrate’s routing layer ships:

An uptime gate that skips any provider whose per-feature success rate drops below 90%.
Feature degradation. If no provider supports the full requested feature set (e.g. json_schema), the request is downgraded (to json_object or text) rather than failed.
Cache-affinity routing. When multiple providers can serve a request, the one where your actor has cached tokens is preferred.

Strategy-driven auto routing

model: "auto" accepts an explicit optimization target via routing.model.sort: cost, latency, or performance (default). See Auto Routing.

Native Responses and Messages APIs

In addition to OpenAI Chat Completions compatibility, Concentrate exposes a first-class Responses API and an Anthropic-compatible Messages API.

Same 0% markup, same consolidated billing

Concentrate charges providers’ list prices with no markup, billed in a single invoice. Helicone does the same with its AI Gateway credits, so if you were drawn to Helicone for the pricing model specifically, that’s not a differentiator either direction.

Troubleshooting

Model not found

Bare slugs (gpt-4o, claude-haiku-4-5) and provider/model-id slugs both work. If you’re using a provider/ prefix and getting a miss, double-check the prefix is a provider (e.g. bedrock, azure, ai-studio) and not just the author (e.g. meta, google). Call GET /v1/models for the authoritative list.

Invalid API key error

Concentrate keys start with sk-cn-v1-. If you are still sending an sk-helicone-... value (or an upstream provider key from proxy mode), you will see a 401. Verify the value in your dashboard and confirm there are no extra spaces or quotes.

Requests succeed but nothing shows up in the Concentrate dashboard

Confirm the base URL is https://api.concentrate.ai/v1, not a *.helicone.ai domain. If the SDK is still pointed at oai.helicone.ai it is logging against your Helicone account, not Concentrate.

Cache hit rate dropped after migrating

Concentrate uses provider-native prompt caching, currently supported on Anthropic and AWS Bedrock. Caches are seeded per API key by default; pass prompt_cache_key in the request body if you want to set the seed explicitly (the analog of Helicone-Cache-Seed).

Connection errors

Confirm the base URL is https://api.concentrate.ai/v1 (no /api segment, no per-provider subdomain). Test the connection manually:

curl https://api.concentrate.ai/v1/responses/health

My retries / rate-limit headers stopped applying

Helicone-Retry-Enabled and Helicone-RateLimit-Policy request headers are no-ops on Concentrate. Failover happens automatically across providers in your fallback chain; rate limits are configured per-key in the dashboard.

Next Steps

API Reference

Explore the full API capabilities

Available Models

Browse all supported models

Auto Routing

Optimize model selection automatically

Get Support

Contact our support team

Feedback

If you hit anything that didn’t translate cleanly (especially around Helicone-Property-*, sessions, prompt versioning, or proxy caching), email support@concentrate.ai. The capability gaps called out above are tracked, and migration friction reports directly shape what we ship next.

Getting started

Migrations

Alerts

Prerequisites

Quick Start for Claude Code users

Step 1: Update Your Environment Variables

Step 2: Update Your Client

Step 3: Remove `Helicone-*` Headers

Step 4: Update Model Identifiers

Step 5: Reconnect Observability

Exporting your Helicone history

Step 6 (Optional): Adopt the Responses API

Why migrate to Concentrate

Troubleshooting

Next Steps

API Reference

Available Models

Auto Routing

Get Support

Feedback

​Prerequisites

​Quick Start for Claude Code users

​Step 1: Update Your Environment Variables

​Step 2: Update Your Client

​Step 3: Remove Helicone-* Headers

​Step 4: Update Model Identifiers

​Step 5: Reconnect Observability

​Exporting your Helicone history

​Step 6 (Optional): Adopt the Responses API

​Why migrate to Concentrate

​Troubleshooting

​Next Steps

API Reference

Available Models

Auto Routing

Get Support

​Feedback

Prerequisites

Quick Start for Claude Code users

Step 1: Update Your Environment Variables

Step 2: Update Your Client

Step 3: Remove `Helicone-*` Headers

Step 4: Update Model Identifiers

Step 5: Reconnect Observability

Exporting your Helicone history

Step 6 (Optional): Adopt the Responses API

Why migrate to Concentrate

Troubleshooting

Next Steps

Feedback