Helicone vs Portkey for the Claude API: which in 2026

If you build anything serious on Claude in 2026, three names keep turning up in architecture diagrams: Helicone, Portkey and codexkey. They get piled together under the heading "LLM infrastructure", although the products are different. Pick wrong and it costs you money, latency, or a missing feature you only notice in production.

The comparison is written by the codexkey team, so we'll say plainly where Helicone and Portkey beat us and where they don't. In short: Helicone and Portkey are observability and routing layers in front of your own Anthropic key. codexkey is a gateway that replaces the Anthropic contract entirely and adds billing, local payments and an EU and Russia footprint on top.

What each product actually does

Helicone: a proxy with deep traces

At its core Helicone is a logging proxy. You change your base_url to Helicone, keep your own Anthropic key, and every request passes through their edge. In return you get traces, sessions, prompt versioning, per-user analytics, evals and a generous free tier. Helicone is friendly to open source and popular with teams that already have an enterprise contract with Anthropic and only lack observability.

What Helicone does not do: pay your Anthropic bill, offer a Russian payment rail, or sell you tokens. It's a layer on top of a relationship you already have.

Portkey: gateway, guardrails, semantic cache

Portkey is more ambitious. It is a full AI gateway: routing across 200+ LLM providers, fallbacks, load balancing, semantic caching, guardrails (PII redaction, output validation), prompt management and observability. You bring your own keys for each provider, and Portkey orchestrates them. The price is made up of a per-event fee (a logged request) and seats.

Portkey shines when you use several providers, work in a regulated industry, or want to A/B test models from different vendors. If all you do is call Claude, it's overkill.

codexkey: a Claude-only gateway with billing built in

codexkey is narrow on purpose. It is a gateway for Claude only with the same Anthropic-compatible API: /v1/messages, streaming, tools, vision, prompt caching and the new April 2026 IDs for Sonnet 4.6 and Opus 4.8. You don't need an Anthropic account. You top up a balance in rubles, dollars or USDT and call our endpoint. The upstream contract, FX and invoicing are on us, and so is the problem that Anthropic doesn't sell directly to half the countries we serve.

codexkey shows usage per named key. You can choose Premium or Cheap for a key, allow a Premium fallback for Cheap, and set an expiry. Budgets, rate limits, model allowlists, IP filters and IDE restrictions can't be configured through the key API.

Feature matrix

SBP is the Russian Faster Payments System.

Pricing models: where it gets interesting

The three products charge in fundamentally different shapes, and that decides who wins on TCO at your scale.

Helicone charges by seats and volume. The free plan covers 100k requests/month, paid plans start at roughly $20 per seat, and usage tiers sit above that. You pay Anthropic separately, at retail. So the bill is Anthropic tokens + Helicone subscription.

Portkey charges per event. You pay for every logged request (roughly $0.001-0.003 depending on the plan) plus seats for the dashboard. Anthropic is billed separately again. At 10M requests/month the gateway alone comes to $10k-30k, on top of your Claude bill.

codexkey charges for the tokens you use. Customer prices for input, output, cache reads and cache writes are in the Models catalog, and the amounts shown are already converted. Usage statistics per key are available in the dashboard.

For a team spending $5k/month on Claude, the math usually works out like this:

• Anthropic direct + Helicone Pro: ~$5,000 + $200 seats ≈ $5,200
• Anthropic direct + Portkey: ~$5,000 + ~$300 events + seats ≈ $5,400
• codexkey (everything bundled): ~$5,500-5,750

So at this scale codexkey is slightly more expensive in plain dollars, and noticeably simpler to operate: one invoice in your local currency and no negotiations with Anthropic. At small volumes (under $500/month) codexkey is cheaper than either alternative, because we have no fixed fees.

Can you use them together?

Yes. codexkey exposes a standard Anthropic-compatible base URL, so codexkey + Helicone is a common setup: point Helicone's proxy at https://api.codexkey.online/v1 instead of https://api.anthropic.com/v1, and you get codexkey's billing together with Helicone's traces. codexkey + Portkey works the same way: you configure a custom Anthropic provider in Portkey with our base URL.

This is genuinely useful. codexkey holds the money and the upstream relationship, while Helicone or Portkey provide the deep observability you actually need. Some customers do exactly this, and we encourage it.

When Helicone wins

• You already have an enterprise contract with Anthropic and you're not changing it.
• You want top-class tracing: session replay, prompt diffs, granular per-user analytics, evals.
• Paying in dollars by card to a US vendor is fine with you.
• The team is small, and the free plan covers you.

If that sounds like you, take Helicone. It does this job better than we do.

When Portkey wins

• You work with several providers: Claude, GPT, Gemini and open source, and you need real routing logic.
• You need guardrails: PII redaction, output schema validation, jailbreak detection out of the box.
• You want a semantic cache to deduplicate near-identical prompts and cut spend.
• You are in a regulated industry and need the audit trail Portkey provides.

Portkey is the right answer for serious AI platforms with a multi-vendor strategy.

When codexkey wins

• You use only Claude (or almost only) and don't want to pay for routing you won't use.
• You have to pay in rubles, through SBP, by a Russian or CIS bank card, or in crypto (USDT, BTC), not by an international card.
• You can't or don't want to sign a direct contract with Anthropic (compliance, geography, procurement friction).
• You want one invoice for tokens, observability and support instead of three vendors.
• You need EU or Russian data residency options for your logs.
• You are a solo developer or a small team who would rather pay a 10-15% margin than juggle two SaaS subscriptions.

These people make up the bulk of our customers: indie developers, small and mid-sized businesses from Russia and the EU, agencies that bill their clients in local currency, and teams that just need it to work.

Code: one client, different gateways

The Anthropic SDK is identical in all three cases. Only the base_url and the key change.

from anthropic import Anthropic

# Direct to Anthropic
client = Anthropic(api_key="sk-ant-...")

# Via Helicone (you still need an Anthropic key)
client = Anthropic(
    api_key="sk-ant-...",
    base_url="https://anthropic.helicone.ai",
    default_headers={"Helicone-Auth": "Bearer sk-helicone-..."},
)

# Via Portkey
client = Anthropic(
    api_key="sk-ant-...",
    base_url="https://api.portkey.ai/v1",
    default_headers={"x-portkey-api-key": "..."},
)

# Via codexkey (no Anthropic key needed)
client = Anthropic(
    api_key="cxa_live_...",
    base_url="https://api.codexkey.online/v1",
)

msg = client.messages.create(
    model="claude-sonnet-5",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Compare gateways."}],
)
print(msg.content[0].text)

Stacking codexkey + Helicone:

client = Anthropic(
    api_key="cxa_live_...",
    base_url="https://anthropic.helicone.ai",
    default_headers={
        "Helicone-Auth": "Bearer sk-helicone-...",
        "Helicone-Target-Url": "https://api.codexkey.online/v1",
    },
)

That puts codexkey's billing and Helicone's traces into one pipeline.

Bottom line

Helicone and Portkey are excellent products, and we recommend them regularly. They are observability and routing layers: they assume you already have a relationship with Anthropic and want to instrument it.

codexkey solves a different problem: getting Claude into production with one invoice, local payments and no contract friction, with observability that is good enough for most teams. If you are in Russia, the CIS or the EU, or you just want one bill instead of three, start with us. If you need the deepest traces or multi-provider guardrails, put Helicone or Portkey on top: we were designed to work well with both.

The least useful question is "which one is better". The right one is "what is on fire in my stack right now", billing, observability or routing. Pick the tool that puts out that particular fire.

Get a codexkey key in two minutes on the sign-up page, top up $5, and point any of these tools at our endpoint to feel the difference.