DEV Community: APIVAI

How to check whether your Claude API relay is serving the real model (what works, what doesn't)

APIVAI — Mon, 19 Oct 2026 12:14:42 +0000

Disclosure: I run APIVAI, a pay-as-you-go gateway for Claude and GPT. I ran the tests below against my own service too, and the results are at the end. The method works on any relay that speaks the native Anthropic format, so use it on mine, on others, or on the one you already pay for.

If you buy Claude through a reseller, a relay or a gateway, you are trusting that a request for claude-sonnet-4-6 actually reaches Claude Sonnet 4.6. That trust is not always deserved:

A CISPA paper accepted to ACM CCS 2026 ("Real Money, Fake Models", arXiv 2603.01919) audited "shadow APIs" used in 187 research papers. On the three it tested in depth, performance diverged by up to 47% and 45.83% of fingerprint checks failed identity verification.
In Chinese developer forums the complaint has its own vocabulary: 以次充好 (passing off a cheaper product), 掺水 (watering down), 降智 (the model "got dumber"). Typical posts: "how do they guarantee it isn't another model?" Reply: "they don't, and they mix them."
On Hacker News, people report being routed to poor quantizations on marketplaces "while paying maybe 15% less".

So how do you check? Most of the advice you will find doesn't work.

Tests that don't work

"Ask it who it is." A relay can inject a system prompt, and real models get their own identity wrong anyway. One survey of 190 models found about 60% misnamed themselves at least once.

"Ask for its knowledge cutoff." A backend serving genuine Claude gave 12 different cutoff dates across 34 asks in one published test. The answer is noise.

"Check the model field in the response." The relay writes that field. It can say anything.

"It feels slower/dumber today." Real regressions exist (Anthropic published a postmortem in 2025 about infrastructure bugs that degraded some Sonnet responses), and so do prompt and context differences. A feeling is not evidence.

The test that does work: the thinking signature

When extended thinking is on, Anthropic returns each thinking block with an opaque signature. In a tool-use conversation you must send the previous assistant turn back, thinking blocks included, and Anthropic verifies that signature. A fake or modified signature is rejected with:

400 invalid_request_error: messages.1.content.0: Invalid `signature` in `thinking` block

That gives you a clean experiment:

Ask a question that makes the model call a tool, with thinking enabled. You get back a thinking block (with a signature) and a tool_use block.
Send the turn back unchanged with a tool result. A genuine backend accepts it.
Send it back again with the last few characters of the signature changed. A genuine backend rejects it with the error above.

Step 3 is the important one. A relay that serves another model can invent a signature string, but it cannot make Anthropic's verifier reject a tampered one and accept the real one, unless the requests really are going to Anthropic.

Supporting signals in the same responses (useful, but forgeable on their own):

Message IDs look like msg_011…, tool-call IDs like toolu_….
usage contains the newer fields: service_tier, inference_geo, and a nested cache_creation object.

The script

Python, standard requests, native Anthropic format. It costs well under a cent on Haiku and about a cent on Sonnet.

import os, requests

BASE = os.environ["RELAY_BASE_URL"]      # e.g. https://your-relay.example (no /v1)
KEY = os.environ["RELAY_API_KEY"]
MODEL = os.environ.get("MODEL", "claude-sonnet-4-6")

H = {"x-api-key": KEY, "anthropic-version": "2023-06-01", "content-type": "application/json"}
TOOLS = [{"name": "get_weather", "description": "Get the weather for a city",
          "input_schema": {"type": "object", "properties": {"city": {"type": "string"}}, "required": ["city"]}}]
THINK = {"type": "enabled", "budget_tokens": 1024}
Q = {"role": "user", "content": "What is the weather in Paris? Use the tool."}

def call(messages):
    r = requests.post(f"{BASE}/v1/messages", headers=H, timeout=120, json={
        "model": MODEL, "max_tokens": 1600, "thinking": THINK, "tools": TOOLS, "messages": messages})
    return r.status_code, r.json()

s, a = call([Q])
blocks = a.get("content", [])
print("1st:", s, a.get("id"), [b["type"] for b in blocks])
print("usage fields:", sorted(a.get("usage", {}).keys()))
tool = next((b for b in blocks if b["type"] == "tool_use"), None)
think = next((b for b in blocks if b["type"] == "thinking"), None)
if not (tool and think and think.get("signature")):
    raise SystemExit("No thinking block with a signature: cannot run the test (try another model or prompt).")

def second(content):
    return call([Q, {"role": "assistant", "content": content},
                 {"role": "user", "content": [{"type": "tool_result", "tool_use_id": tool["id"], "content": "Sunny, 18C"}]}])

s2, b2 = second(blocks)
print("2nd, signature unchanged:", s2, "(expect 200)")

bad = [dict(b, signature=b["signature"][:-8] + "AAAAAAAA") if b["type"] == "thinking" else b for b in blocks]
s3, b3 = second(bad)
print("3rd, signature tampered:", s3, b3.get("error", {}).get("message", ""), "(expect 400 Invalid `signature`)")

Read the result like this:

2nd call	3rd call	Meaning
200	400 "Invalid `signature`"	Requests reach Anthropic's Claude and the relay passes thinking blocks through intact
200	200	Nobody is checking signatures: not a genuine Anthropic backend
400	400	The relay breaks thinking blocks (common when it converts to OpenAI format); Claude Code multi-turn sessions will hit this too

What this test cannot tell you

Be clear about the limits, because nobody can prove more than this from the outside:

It proves "Anthropic's Claude", not "which Claude". A relay that quietly sends your Opus requests to Sonnet, both on Anthropic, passes. To catch tier swaps, compare cost and latency against the official API on the same prompts, or run a small fixed set of hard questions from time to time.
It's a point in time. Relays change backends. Run it again now and then, and on the models you actually use.
It needs the native Anthropic format. OpenAI-format endpoints drop thinking signatures, so you can't run it there.
Passing is "no evidence of substitution", not proof. That's also the conclusion of the academic audits; only hardware attestation would be real proof, and no reseller channel offers it.

Other things worth checking before you prepay anyone

These come from complaints that keep recurring in forums:

Billing you can reconcile: per-request logs with input, output, cache-read and cache-write tokens and the cost of each request. Cache hit rates that never change from request to request are a red flag.
Prices next to the official price, and notice before any change. "They silently changed my group/multiplier and burned my balance" is a common story.
Small top-ups and a written refund policy for unused balance. Relays that vanish with prepaid balances are not rare.
A clear statement of what is logged. Metadata (tokens, model, cost) is normal; request and response content should not be stored.
Honest limits: rate limits and concurrency stated up front, not "upstream fluctuation" after the fact.

My own results

I ran the script against my service (APIVAI) through its public endpoint on Claude Haiku 4.5, and against Claude Sonnet 4.6 on the same backend:

1st call: msg_011… ID, toolu_… tool ID, usage with service_tier, inference_geo and nested cache_creation, and a thinking block with a signature.
2nd call (unchanged signature): 200.
3rd call (tampered signature): 400 Invalid \signaturein \thinkingblock.
Not present: anthropic-ratelimit-* response headers, so I can't offer those as a signal.

That is all the test shows, with the limits above. If you run it against any relay, including mine, I'd be glad to see the results in the comments, especially failures.

LobeChat (LobeHub) with Claude and GPT: custom provider, Docker env vars and the /v1 rule

APIVAI — Mon, 19 Oct 2026 09:19:21 +0000

Disclosure: I run APIVAI, the gateway used in the examples below. The setup is the same for any endpoint that speaks the OpenAI or Anthropic format.

LobeChat is now called LobeHub: the GitHub repo lobehub/lobe-chat redirects to lobehub/lobehub, and the Docker image is lobehub/lobehub. It's an open-source chat and agent app that runs on the web, as a desktop app, or self-hosted, and every agent can use its own provider and model. This guide follows the LobeHub docs and UI labels as of October 2026: how to add a third-party API, where /v1 goes, and the usual pitfalls.

Three ways to connect

Method	URL	Models	Best for
Custom provider, Request Format = OpenAI	`https://api.apivai.com/v1`	Claude and GPT	Recommended: one provider for every model, built-in OpenAI provider untouched
Built-in Anthropic provider	`https://api.apivai.com`	Claude only	Claude in its native Messages format
Built-in OpenAI provider	`https://api.apivai.com/v1`	Claude and GPT	Quickest, but replaces the OpenAI provider (breaks file indexing, see below)

The /v1 rule: OpenAI-format URLs end in /v1; Anthropic-format URLs don't, because the Anthropic SDK appends /v1/messages itself.

Adding a custom provider

Open App Settings → AI Providers.
Click Add Custom Provider to open Create Custom AI Provider.
Fill in the fields below and click Create.

Field	Value
Provider ID	`apivai` (lowercase; can't be changed later)
Provider Name	APIVAI
Request Format	OpenAI
Proxy URL	`https://api.apivai.com/v1`
API Key	your key
Use Client Request Mode	off

Use Client Request Mode sends requests straight from the browser instead of through the LobeHub server. Leave it off unless you have a reason; if you turn it on and get network errors, turn it off again.

Then, on the provider's page:

Run Connectivity Check: pick a model, click Check, and you should see Check passed.
Click Fetch models to pull IDs from /v1/models, and switch on the ones you want. Or click Add Model and type a Model ID such as claude-sonnet-4-6 or gpt-5.5.
In an agent's settings, choose this provider and a model.

To see which IDs your key can use:

curl https://api.apivai.com/v1/models \
  -H "Authorization: Bearer your-key"

Alternative: the built-in Anthropic provider

In AI Providers, select Anthropic and enable it. Paste the key into API Key and set API Proxy URL to https://api.apivai.com (no /v1). Run Check, then enable Claude models. If a built-in model card has a different ID from the gateway's, add the correct one with Add Model; if Fetch models returns nothing here, add models by hand.

If you use the built-in OpenAI provider instead, set API Proxy URL to https://api.apivai.com/v1 and leave Use Responses API Specification off: LobeHub says it only supports OpenAI models, and you'll be sending Claude requests through it too.

Self-hosting: Docker environment variables

A self-hosted LobeHub server reads providers from environment variables. Add these to your lobehub.env, next to the database and auth variables you already have:

# OpenAI format: Claude and GPT
OPENAI_API_KEY=your-key
OPENAI_PROXY_URL=https://api.apivai.com/v1
OPENAI_MODEL_LIST=-all,+claude-sonnet-4-6,+claude-haiku-4-5,+gpt-5.5

# Or Anthropic format: Claude only
ANTHROPIC_API_KEY=your-key
ANTHROPIC_PROXY_URL=https://api.apivai.com

Start the container as usual, e.g. docker run -d -p 3210:3210 --env-file lobehub.env --name lobehub lobehub/lobehub, and restart it after every change to the file.

OPENAI_MODEL_LIST syntax: -all hides the default OpenAI models, +id adds a model, id=Display Name renames one. A key set here is a server key shared by every user of your instance, so give it its own budget limit. The LobeHub docs note that empty replies are often caused by OPENAI_PROXY_URL missing /v1; keep it there.

Do files and the knowledge base work?

Chat works fully. Files and the knowledge base also need an embedding model to index documents, and APIVAI doesn't offer embeddings.

By default LobeHub creates embeddings with OpenAI's text-embedding-3-small through the OpenAI provider. If you point OPENAI_PROXY_URL at the gateway, file indexing fails, which is one more reason to chat through a custom provider. Configure embeddings separately with DEFAULT_FILES_CONFIG, e.g. DEFAULT_FILES_CONFIG=embedding_model=ollama/<your-embedding-model>; the supported providers are listed in LobeHub's knowledge-base deployment guide. Answers about your files still come from the Claude or GPT model you picked.

Which model for which job

General assistant, quick questions: claude-haiku-4-5 or gpt-6-luna
Writing and coding agents: claude-sonnet-4-6 or claude-sonnet-5-5
The hardest analysis and long-form writing: claude-opus-5-5, only where it's needed
Current GPT: gpt-6-sol

Every message re-sends the conversation so far, so long chats get more expensive per message; start a new topic when the subject changes.

Common errors

401 / API key invalid: the key has extra spaces, is incomplete, or has been deleted.
402 / insufficient_quota: the key's budget is used up, or what's left is too little for one request to an expensive model (Opus, Sonnet 4.6 hit this first). Add budget to the key or switch to a cheaper model. A key stops working with a little still on it; that remainder isn't lost, because deleting the key returns it to your account balance.
404: the /v1 is wrong. OpenAI format (custom provider, OpenAI provider, OPENAI_PROXY_URL) needs https://api.apivai.com/v1; Anthropic format needs https://api.apivai.com. Don't add /chat/completions or /messages.
Model not found: the Model ID must match the gateway's ID exactly, such as claude-sonnet-4-6, not the display name. Check with Fetch models or GET /v1/models.
Empty or cut-off replies: thinking is on by default and counts as output tokens. In the agent's model settings, turn on Enable Max Tokens Limit and set Max Tokens Limit to 4096 or more. For empty replies in OpenAI format, also check that the URL ends in /v1.
Environment variables ignored: restart the container after editing lobehub.env, and check the variable names match exactly.
429: the default limit is 60 requests per minute per key. A shared instance can hit it; split usage across keys.

What it costs

At the time of writing, most Claude models on APIVAI are 56–62% below Anthropic's list prices and GPT models up to 86% below OpenAI's; for example, Claude Sonnet 4.6 is $1.26 / $6.32 per million input / output tokens against the official $3 / $15. It's prepaid and billed per token, with no subscription. The full table is at https://apivai.com/pricing?utm_source=devto&utm_campaign=lobechat.

Questions are welcome in the comments.

Dify with Claude and GPT: every field of the OpenAI-API-compatible plugin, explained

APIVAI — Fri, 16 Oct 2026 07:33:36 +0000

Disclosure: I run APIVAI, the gateway used in the examples below. The setup is the same for any endpoint that speaks the OpenAI or Anthropic format.

Dify is an open-source platform for building LLM apps: chatbots, agents, workflows and knowledge-base (RAG) apps. It reaches models through model provider plugins, and with a third-party gateway there are enough fields that it's easy to fill one in wrong. This post goes through the actual fields of Dify's official openai_api_compatible plugin (version 0.0.68) and the anthropic plugin.

Which provider plugin?

Plugin	Address field	Models	Best for
OpenAI-API-compatible	API Base URL: `https://api.apivai.com/v1`	Claude and GPT	One provider for every model; you type the model IDs
Anthropic	API URL: `https://api.apivai.com`	Claude only	Claude only, in the native format with prompt caching

Start with OpenAI-API-compatible: you type each model ID yourself, so a new model works as soon as the gateway lists it.

Providers live on the Model Provider page: under Integrations in current Dify Cloud, under Settings in the account menu in older self-hosted versions. Each provider applies to the whole workspace, and only owners and admins can change it.

Step 1: Install the plugin

Open Model Provider, find OpenAI-API-compatible in the list of providers you can install (or on the Dify Marketplace) and click Install.

Step 2: Add a model

On the OpenAI-API-compatible card, click Add Model and fill in:

Field	Value
Model Type	LLM
Model Name	`claude-sonnet-4-6` (the exact model ID)
Model display name	optional, e.g. "Claude Sonnet 4.6"
API Key	your key
API Base URL	`https://api.apivai.com/v1`
model name for API endpoint	leave empty
Completion mode	Chat
Model context size	no larger than the model's context window
Upper bound for max tokens	8192 or more
Function Call Type	Tool Call
Stream function calling	Support
API Type	Chat Completions API (/chat/completions)

Leave the rest at their defaults. Older versions of the plugin call the address field API endpoint URL; the value is the same.

The fields people most often misread:

Model Name is what Dify actually sends to the API, so it must be the exact ID. The display name is only for the interface.
Model context size is the limit Dify uses when it fits history and retrieved knowledge into the prompt. A value below the model's real window is fine and keeps long chats cheaper.
Upper bound for max tokens only sets how high Max Tokens can go in your apps. Thinking is on by default and counts as output, so leave room above 4096.
Function Call Type: Tool Call is what lets Agent apps use native tool calling.

When you click Save, Dify sends a test request and only saves if it passes. Repeat Add Model for each model you want, with the same key and address, for example gpt-5.5 and claude-haiku-4-5.

Take model IDs from the API:

curl https://api.apivai.com/v1/models -H "Authorization: Bearer your-key"

Step 3: Use the models

In an app's model selector, pick your model under OpenAI-API-compatible and set Max Tokens to 4096 or more.
In a workflow, each LLM node picks its own model, so cheap and strong models can sit in the same flow.
Under Default Models on the Model Provider page, set the System Reasoning Model as the workspace default.

Alternative: the Anthropic plugin for Claude

Install the Anthropic plugin and open its setup.
Set API Key to your key and API URL to https://api.apivai.com. Do not add /v1; the plugin's Anthropic client appends /v1/messages itself. Leave Enable request metadata on Disabled.
Some IDs in the plugin's built-in model list match the gateway's (such as claude-sonnet-4-6); others have different or dated names. If a model is missing or returns "model not found", click Add Model on the Anthropic card and type the exact ID.

Which model for which job

Question Classifier nodes, extraction, high-volume Q&A: claude-haiku-4-5 or gpt-6-luna
Default for chatbots and agents: claude-sonnet-4-6
Agents with many tools, long documents: claude-sonnet-5-5
Only the hardest reasoning nodes: claude-opus-5-5

A routing workflow (a cheap model classifies first, then hands the hard cases to a strong one) is the most common way to keep Dify costs down.

Common errors

Credentials validation fails on save / 401: the key is incomplete or deleted. Also check that API Base URL has /v1 exactly once.
402 / insufficient_quota: the key's budget is used up, or what's left is too little for one request to an expensive model (Opus, Sonnet 4.6 hit this first). Add budget to the key or move that node to a cheaper model. A key stops working with a little still on it; that remainder isn't lost, and deleting the key returns it to your account balance.
404: OpenAI-API-compatible needs https://api.apivai.com/v1, without /chat/completions; the Anthropic plugin needs https://api.apivai.com without /v1.
Model not found: Model Name holds a display name instead of the ID, or you used a dated name from the Anthropic plugin's built-in list.
Empty or cut-off answers: Max Tokens in the app is too low (thinking uses output tokens); raise it to 4096 or more, and make sure Upper bound for max tokens is high enough.
The agent never calls tools: Function Call Type isn't set to Tool Call.
Knowledge base errors: a knowledge base needs an embedding model, and APIVAI doesn't provide embeddings. Set up a separate embedding provider for it; the LLM that writes the answer can still be Claude or GPT.
429: each key allows 60 requests per minute and 5 at once (extra ones wait in a queue for a while). For busy apps, give each app its own key.

What it costs

Questions are welcome in the comments.

Roo Code with Claude and GPT: OpenAI Compatible vs Anthropic, and one model per mode

APIVAI — Mon, 12 Oct 2026 13:57:34 +0000

Disclosure: I run APIVAI, the gateway used in the examples below. The setup is the same for any endpoint that speaks both the OpenAI and Anthropic formats.

Roo Code is an open-source coding agent for VS Code. It shares its roots with Cline but adds modes (Code, Architect, Ask, Debug) and configuration profiles. Used together, they let planning, coding and quick questions each run on a different model. This post covers the two provider types that work with a gateway, how to set up profiles per mode, and the common errors.

OpenAI Compatible or Anthropic?

	OpenAI Compatible	Anthropic
Base URL	`https://api.apivai.com/v1`	`https://api.apivai.com` (no `/v1`)
Models	Claude and GPT	Claude only
Picking a model	Type the model ID	Choose from Roo Code's list
Best for	Mixing Claude and GPT, newest model IDs	Long Claude sessions, with prompt caching

The prompt caching part is worth a note. Roo Code's Anthropic provider adds cache_control markers to the system prompt and recent messages, so repeated context is billed at the cache-read price, which is much lower than the full input price. An agent resends a lot of context on every step, so if you only use Claude, the Anthropic provider is usually cheaper.

Step 1: Set up OpenAI Compatible

Open the Roo Code panel in VS Code, click the gear icon and go to Providers.
Set API Provider to OpenAI Compatible.
Fill in the fields below and save.

Field	Value
Base URL	`https://api.apivai.com/v1`
API Key	your key
Model	`claude-sonnet-4-6` (or any ID from `GET /v1/models`)
Max Output Tokens	8192 or more (at least 4096)

The base URL ends in /v1 exactly once; Roo Code appends /chat/completions itself. Leave Context Window, Image Support and Computer Use at their defaults unless you have a reason to change them. The Input/Output Price fields only change the cost estimate Roo Code shows; they don't affect billing.

Roo Code uses native tool calling only, so the model must support function calling. The main Claude and GPT models do.

To see which model IDs your key can use:

curl https://api.apivai.com/v1/models \
  -H "Authorization: Bearer your-key"

Step 2: Add an Anthropic profile (recommended if you only use Claude)

In Providers, click the + next to the profile selector and name the profile, for example "APIVAI Claude".
Set API Provider to Anthropic.
Paste your key into Anthropic API Key.
Tick Use custom base URL and enter https://api.apivai.com.
Choose a Claude model from the Model dropdown.

Do not add /v1 here. Roo Code passes this address to the Anthropic SDK, which appends /v1/messages on its own, so https://api.apivai.com/v1 turns into /v1/v1/messages and returns 404.

Step 3: Give each mode its own profile

Roo Code remembers which profile you last used in each mode, and its mode settings let you assign a profile to a mode explicitly. All profiles can share the same key.

Which model for which job

Mode	Model	Why
Architect (planning)	`claude-opus-5-5`	A wrong plan wastes everything after it
Code / Debug	`claude-sonnet-4-6` or `claude-sonnet-5-5`	The everyday default
Ask	`claude-haiku-4-5` or `gpt-6-luna`	Just questions; cheap and fast is enough

If a task keeps going in circles on Sonnet, switch that task to Opus rather than making Opus your default. GPT models only work through an OpenAI Compatible profile.

Common errors

401 / invalid key: the key is incomplete or deleted. With the Anthropic provider, also check that Use custom base URL is ticked, or Roo Code sends your key to Anthropic directly.
402 / insufficient_quota: the key's budget is used up, or what's left is too little for one request to an expensive model (Opus, Sonnet 4.6 hit this first, so Architect on Opus is the usual place to see it). Add budget to the key or switch to a cheaper model. A key stops working with a little still on it; that remainder isn't lost, and deleting the key returns it to your account balance.
404: almost always /v1. OpenAI Compatible needs https://api.apivai.com/v1 (one /v1, no /chat/completions); Anthropic needs https://api.apivai.com without /v1.
Model not found: use the exact ID, such as claude-sonnet-4-6, not the display name. Check it against GET /v1/models.
Tool-calling errors: switch to a model that supports function calling.
Empty or cut-off replies: thinking is on by default and uses output tokens. Raise Max Output Tokens to 8192 (at least 4096).
429: the default limit is 60 requests per minute per key. Long tasks can hit it; wait a moment or split work across several keys.

What it costs

At the time of writing, most Claude models on APIVAI are 56–62% below Anthropic's list prices and GPT models up to 86% below OpenAI's; for example, Claude Sonnet 4.6 is $1.15 / $5.74 per million input / output tokens against the official $3 / $15. It's prepaid and billed per token, with no subscription. The full table is at https://apivai.com/pricing.

Questions are welcome in the comments.

Cherry Studio with Claude and GPT: adding a custom provider (and the /v1 question)

APIVAI — Mon, 12 Oct 2026 13:56:56 +0000

Disclosure: I run APIVAI, the gateway used in the examples below. The setup is the same for any endpoint that speaks both the OpenAI and Anthropic formats.

Cherry Studio is a free desktop AI client for Windows, macOS and Linux, with assistants, knowledge bases, MCP tools and side-by-side answers from several models. It has no models of its own: you add a provider and a key. This post covers how to add a custom provider, whether the address needs /v1, and the errors people run into most.

Custom provider or the built-in Anthropic provider?

	Custom provider (OpenAI endpoint)	Built-in Anthropic provider
Where	Settings → Model Services → + Add Provider	Settings → Model Services → Anthropic
Address	`https://api.apivai.com`	`https://api.apivai.com`
Models	Claude and GPT	Claude only
Best for	One entry for every model	Claude in its native Messages format

For most people the custom provider is enough: one key, with Claude and GPT in the same model list. You can also set up both with the same key.

Step 1: Add a custom provider

Click Settings (the gear icon in the left navigation bar).
Open Model Services.
Click + Add Provider below the provider list.
Fill in the dialog as below and click Add.

Field	Value
Provider Name	anything you'll recognise, e.g. `APIVAI`
API Key	your key
OpenAI endpoint (API Address)	`https://api.apivai.com`

About /v1: Cherry Studio wants the base address and appends /v1/chat/completions itself, so https://api.apivai.com becomes https://api.apivai.com/v1/chat/completions. Current versions also accept https://api.apivai.com/v1 without doubling it, but never paste the full /v1/chat/completions address. A trailing # means "use this address exactly as typed"; you don't need it here.

Older versions ask for a Provider Type instead; choose OpenAI.

Step 2: Add the models

Open the provider you just created.
Click Get model list and click the + next to each model you want. Only models you've added with + show up in the chat's model picker.
Or click + and type a model ID, such as claude-sonnet-4-6, claude-haiku-4-5 or gpt-5.5.

The list changes over time, so take IDs from Get model list rather than from old screenshots.

Step 3: Test and switch it on

Click Test (named Check in some versions) and pick a model. A success message means the key and address are right.
Turn the provider on with the switch in the upper-right corner of the provider page. An enabled provider shows a green dot in the list.
Pick the model from the drop-down at the top of a chat and send a message.

Optional: Claude through the built-in Anthropic provider

In Model Services, open Anthropic, paste your key into API Key and change API Address from https://api.anthropic.com to https://api.apivai.com. Do not add /v1; the address has the same shape as Anthropic's own. Then click Get model list, add the Claude models you want and switch the provider on. GPT models won't work here; they go through the custom provider above.

Which model for which job

Default assistant (quick questions, translation, summaries): claude-haiku-4-5 or gpt-6-luna, cheap and fast
Main assistant (writing, code): claude-sonnet-4-6 or claude-sonnet-5-5
The hardest analysis and reasoning: claude-opus-5-5, only when you need it
Comparing models: Cherry Studio can send one question to several models at once, which is the most direct way to compare them on your own tasks

Every message resends the conversation so far, so long chats cost more per turn. Start a new topic when the subject changes.

What about knowledge bases?

Chat works fine, but a knowledge base needs an embedding model to index your files, and APIVAI doesn't provide embeddings. Configure a separate embedding provider for the knowledge base in Cherry Studio; the assistant that answers can still be a Claude or GPT model. Image generation models aren't available either.

Common errors

401 / invalid API key: the key is incomplete or has been deleted.
402 / insufficient_quota: the key's budget is used up, or what's left is too little for one request to an expensive model (Opus, Sonnet 4.6 hit this first). Add budget to the key or switch to a cheaper model. A key stops working with a little still on it; that remainder isn't lost, and deleting the key returns it to your account balance.
404: the address is wrong. The custom provider takes https://api.apivai.com, without /chat/completions and without a trailing #; the Anthropic provider takes https://api.apivai.com without /v1.
Model not found: the ID must match exactly (e.g. claude-sonnet-4-6), not the display name. GPT models fail on the Anthropic provider.
Model missing from the chat picker: the provider switch is off, or you fetched the list but didn't click + next to the model.
Empty or cut-off replies: thinking tokens count towards the output limit. In Edit Assistant → Model, turn off Enable message length limit (MaxToken) or set it to 4096 or more.
Replies arrive all at once, or the stream stops: check the Streaming output (Stream) switch on the same tab, and any proxy in Cherry Studio's network settings.
429: the default limit is 60 requests per minute per key. Comparing several models at once uses several requests; wait a moment and try again.

What it costs

Questions are welcome in the comments.

Cline with Claude and GPT through your own API gateway: OpenAI Compatible vs Anthropic, and the /v1 trap

APIVAI — Mon, 12 Oct 2026 12:59:50 +0000

Disclosure: I run APIVAI, the gateway used in the examples below. The setup is the same for any endpoint that speaks both the OpenAI and Anthropic formats.

Cline is an open-source coding agent for VS Code. It reads your files, proposes edits and runs commands with your approval, but it ships without a model: you bring a provider and a key. Cline offers two provider types that work with a third-party gateway, and most setup errors come from mixing up their base URLs. Here is how they differ and how to fill in each one.

OpenAI Compatible or Anthropic?

	OpenAI Compatible	Anthropic
Base URL	`https://api.apivai.com/v1`	`https://api.apivai.com` (no `/v1`)
Models	Claude and GPT	Claude only
Picking a model	Type the model ID	Choose from Cline's list
Best for	One setup for every model	Claude in its native Messages format

Pick OpenAI Compatible if you want to switch between Claude and GPT, or use a model ID newer than Cline's built-in list. Pick Anthropic if you only use Claude. The same key works in both, and you can switch at any time.

Setting up OpenAI Compatible

Open the Cline panel in VS Code and click the gear icon.
Set API Provider to OpenAI Compatible.
Fill in the fields below, click Verify if your version has it, and save.

Field	Value
Base URL	`https://api.apivai.com/v1`
API Key	your key
Model	`claude-sonnet-4-6` (or any ID from `GET /v1/models`)
Max Output Tokens	8192 or more (at least 4096)

The base URL must end in /v1 exactly once, because Cline appends /chat/completions itself. Leave Context Window, Image Support and Computer Use at their defaults unless you know you need them. The Input/Output Price fields only change the cost estimate Cline shows; they don't affect billing.

To see which model IDs your key can use:

curl https://api.apivai.com/v1/models \
  -H "Authorization: Bearer your-key"

Copy IDs from that response rather than from old tutorials; the list changes.

Setting up Anthropic (Claude only)

Set API Provider to Anthropic.
Paste your key into Anthropic API Key.
Tick Use custom base URL and enter https://api.apivai.com.
Pick a Claude model from the dropdown.

Do not add /v1 here. Cline's Anthropic client appends /v1/messages on its own, so https://api.apivai.com/v1 turns into /v1/v1/messages and returns 404. If the Claude model you want isn't in Cline's list yet, use the OpenAI Compatible provider and type the ID.

Which model for which job

Cline re-sends the conversation and every file it has read on each step, so input tokens add up quickly and the price per token matters more than in a chat app. A practical split:

Everyday coding: claude-sonnet-4-6 or claude-sonnet-5-5
Hard bugs and large refactors, when Sonnet keeps going in circles: claude-opus-5-5
Renames, comments, small fixes: claude-haiku-4-5
A second opinion: gpt-5.5 (OpenAI Compatible only)

Common errors

401 / invalid key: the key is incomplete or deleted. With the Anthropic provider, also check that Use custom base URL is ticked, or Cline sends your key to Anthropic directly.
402 / insufficient_quota: the key's budget is used up, or what's left is too little for one request to an expensive model (Opus, Sonnet 4.6). Add budget to the key or switch to a cheaper model.
404: almost always /v1. OpenAI Compatible needs https://api.apivai.com/v1 (one /v1, no /chat/completions); Anthropic needs https://api.apivai.com without /v1.
Model not found: use the exact ID, such as claude-sonnet-4-6, not the display name.
Empty or cut-off replies: thinking is on by default and uses output tokens. Raise Max Output Tokens to 8192 (at least 4096).
429: the default limit is 60 requests per minute per key. Long agent runs can hit it; wait a moment or split work across keys.

What it costs

Questions are welcome in the comments.

Pointing Codex CLI at your own API gateway: config.toml, keys and common errors

APIVAI — Thu, 08 Oct 2026 11:06:46 +0000

Disclosure: I run APIVAI, the gateway used in the examples below. The same config works with any endpoint that supports the OpenAI Responses API.

Codex CLI talks to OpenAI by default, but it lets you define your own model provider in its config file. That means you can point it at another gateway with a few lines of TOML. Here is the setup, where the key goes, and the mistakes that cause most of the errors.

Codex uses the Responses API

Unlike most tools, Codex CLI does not call /v1/chat/completions. It uses OpenAI's Responses API (/v1/responses). Whatever endpoint you point it at has to support that API, or tool calls and streaming will break. The wire_api = "responses" line in the config tells Codex which API to use.

Step 1: the config file

Location:

macOS / Linux: ~/.codex/config.toml
Windows: %USERPROFILE%\.codex\config.toml

model = "gpt-5.5"
model_provider = "apivai"

[model_providers.apivai]
name = "APIVAI"
base_url = "https://api.apivai.com/v1"
env_key = "OPENAI_API_KEY"
wire_api = "responses"

Field	What it does
`model`	Default model ID
`model_provider`	Which provider to use; must match the `[model_providers.xxx]` name
`base_url`	Endpoint, with `/v1`; Codex appends `/responses`
`env_key`	Environment variable that holds the key
`wire_api`	`responses`

Step 2: the key

The key does not go in the config file. Codex reads it from the variable named in env_key.

export OPENAI_API_KEY="your-key"
codex "explain what this repo does in two sentences"

Windows PowerShell:

$env:OPENAI_API_KEY = "your-key"
codex "explain what this repo does in two sentences"

Start with a small question like this before you let it edit code.

Step 3: check the model ID

curl https://api.apivai.com/v1/models \
  -H "Authorization: Bearer your-key"

To switch models for one run, pass -m:

codex -m gpt-5.5 "add unit tests for utils.py"

Common errors

401 Unauthorized: Codex can't see the key. Check that the variable name in env_key matches the one you set, and that it is set in the terminal you're using (echo $OPENAI_API_KEY).
404 Not Found: base_url must be https://api.apivai.com/v1. Don't drop /v1, and don't add /responses yourself.
"provider not found", or requests not reaching the gateway: the model_provider value must match the [model_providers.xxx] name exactly, and you must be editing the right config.toml.
Tool calls fail or output hangs: wire_api is missing or set to chat, or the endpoint doesn't support the Responses API.
Model not found: use an exact ID from GET /v1/models.
429: the default limit is 60 requests per minute per key.

What it costs

At the time of writing, GPT models on APIVAI are up to 86% below OpenAI's list prices and Claude models 56–62% below Anthropic's. It's prepaid and billed per token, with no subscription. The full table is at https://apivai.com/pricing, and setup guides for other tools are at https://apivai.com/blog.

Questions are welcome in the comments.

Running Claude Code, Cursor and Codex CLI through one API key

APIVAI — Wed, 07 Oct 2026 18:50:56 +0000

Disclosure: I run APIVAI, the gateway used in the examples below. The setup steps work the same way with any endpoint that speaks the Anthropic and OpenAI formats.

Most AI coding tools let you change the API base URL. That means you can point Claude Code, Cursor, Codex CLI, Cline and the official SDKs at a single gateway and manage one key and one balance instead of several.

Claude Code

Claude Code speaks the Anthropic Messages format. Set two environment variables:

export ANTHROPIC_BASE_URL="https://api.apivai.com"
export ANTHROPIC_AUTH_TOKEN="your-key"
claude

On Windows PowerShell:

$env:ANTHROPIC_BASE_URL = "https://api.apivai.com"
$env:ANTHROPIC_AUTH_TOKEN = "your-key"
claude

Cursor

Settings → Models → API Keys: turn on Override OpenAI Base URL, enter https://api.apivai.com/v1, paste your key, then add the model IDs you want (for example claude-sonnet-4-6).

OpenAI SDK (Python)

from openai import OpenAI

client = OpenAI(api_key="your-key", base_url="https://api.apivai.com/v1")
r = client.chat.completions.create(
    model="claude-sonnet-4-6",
    messages=[{"role": "user", "content": "Hello"}],
)
print(r.choices[0].message.content)

Common errors

401: the key is wrong, or it was sent in the wrong header. Use x-api-key or Authorization: Bearer.
404: usually a /v1 mismatch. Anthropic-format tools use the root URL, OpenAI-format tools need /v1.
429: the default limit is 60 requests per minute per key.

What it costs

At the time of writing, Claude models on APIVAI are 56–62% below Anthropic's list prices and GPT models up to 86% below OpenAI's. For example, Claude Sonnet 4.6 is $1.15 / $5.74 per million input / output tokens against the official $3 / $15. It's prepaid and pay-per-token, with no subscription. The full table is at https://apivai.com/pricing.

Setup guides for Cline, Roo Code, Aider, Continue, Open WebUI and others are on the blog: https://apivai.com/blog

Questions are welcome in the comments.

How to Connect Roo Code to APIVAI (Cheap API for an AI Coding Agent)

APIVAI — Sun, 28 Jun 2026 20:07:22 +0000

Connect Roo Code to APIVAI

Roo Code (formerly Roo Cline) is a popular autonomous
coding agent for VS Code. It supports OpenAI-compatible providers, so you can run it on APIVAI's
Claude and GPT models — agentic edits cost a lot of tokens, so a cheap compatible gateway matters.

Configure the provider

Open Roo Code's settings (the gear icon in the Roo panel).
API Provider: choose OpenAI Compatible.
Set:
- Base URL: https://api.apivai.com/v1
- API Key: your APIVAI key
- Model: a name APIVAI serves (e.g. claude-sonnet-4-6 or gpt-5.5)
Save.

Roo Code now routes its requests through APIVAI.

Pick a model

Confirm valid names:

curl -s https://api.apivai.com/v1/models \
  -H "Authorization: Bearer $APIVAI_API_KEY"

Claude Sonnet is a strong default for agentic coding; use it for multi-step edits and reasoning.

Tips for agent workloads

Agents send many large requests — a discounted gateway like APIVAI noticeably lowers the bill.
Prefer a model with a large context window for big files/repos.
Make sure streaming passes through so you see progress as the agent works.

Troubleshooting

401 — check the key and that the provider is "OpenAI Compatible" with Base URL ending /v1.
model_not_found — use a name from /v1/models.
Truncated output — raise max tokens / pick a larger-context model.

FAQ

Does Roo Code work with APIVAI? Yes — select "OpenAI Compatible", set Base URL
https://api.apivai.com/v1 and your APIVAI key.

Which model for Roo Code? Claude Sonnet for agentic coding and reasoning; GPT-5.5 for faster,
cheaper runs.

Why use a gateway for an agent? Coding agents burn tokens; APIVAI's discounted, OpenAI-compatible
access cuts the cost without changing your workflow.

Get started

Set the OpenAI-compatible provider in Roo Code with APIVAI's base URL + key and a model from
/v1/models. Examples: APIVAI examples repo.

How to Build a Telegram AI Bot with APIVAI (Cheap Claude & GPT)

APIVAI — Sun, 28 Jun 2026 20:07:18 +0000

Build a Telegram AI bot with APIVAI

A Telegram AI bot is one of the quickest ways to ship an AI assistant: create a bot with BotFather,
run a small script that forwards messages to an OpenAI-compatible model, and reply. APIVAI provides
the model (Claude or GPT) at a fraction of list price, with crypto/USDT/Alipay payment.

This guide is the full working bot.

1. Create the bot

Message @botfather on Telegram → /newbot → choose a name → copy the bot token.

2. The bot (Node.js, long polling — no server needed)

npm install node-telegram-bot-api openai

import TelegramBot from "node-telegram-bot-api";
import OpenAI from "openai";

const bot = new TelegramBot(process.env.TELEGRAM_BOT_TOKEN, { polling: true });
const ai = new OpenAI({ apiKey: process.env.APIVAI_API_KEY, baseURL: "https://api.apivai.com/v1" });
const SYSTEM = "You are a helpful assistant. Answer concisely in the user's language.";

const history = new Map(); // chatId -> messages[]

bot.on("message", async (msg) => {
  if (!msg.text || msg.text.startsWith("/")) return;
  const chatId = msg.chat.id;
  const msgs = history.get(chatId) || [{ role: "system", content: SYSTEM }];
  msgs.push({ role: "user", content: msg.text });

  bot.sendChatAction(chatId, "typing");
  const r = await ai.chat.completions.create({ model: "gpt-5.5", messages: msgs.slice(-12), max_tokens: 500 });
  const reply = r.choices[0].message.content;

  msgs.push({ role: "assistant", content: reply });
  history.set(chatId, msgs.slice(-12)); // keep recent context
  bot.sendMessage(chatId, reply);
});

Set TELEGRAM_BOT_TOKEN and APIVAI_API_KEY, run node bot.js, and message your bot.

3. Add commands & polish

/start → a welcome message; /reset → clear that chat's history.
Trim history (last ~12 messages) to control token cost.
Stream long answers by editing the message as chunks arrive (optional).
For groups, only respond when mentioned or replied to.

Pick the model

GPT-5.5 for fast, natural, multilingual replies; Claude Sonnet for coding/long-reasoning bots.
Switch by changing the model string — it's OpenAI-compatible.

FAQ

Can a Telegram bot use APIVAI? Yes — it's a normal OpenAI chat call with the base URL set to
https://api.apivai.com/v1; the bot forwards messages and returns the reply.

Do I need a server? No — long polling (above) runs anywhere Node runs. Use webhooks if you want
a serverless deployment.

Which model should the bot use? GPT-5.5 for general/multilingual chat; Claude Sonnet for
code-heavy bots.

How do I control cost? Trim conversation history and cap max_tokens; APIVAI's per-token price
is already low.

Get started

Create a bot with BotFather, drop in the script with your APIVAI key, and run it. Examples:
APIVAI examples repo.

The Cheapest Way to Use Claude & GPT APIs in 2026

APIVAI — Thu, 25 Jun 2026 15:46:00 +0000

The cheapest way to use Claude & GPT in 2026

If you run AI coding agents or apps all day, the API bill is usually your biggest cost. The good news: you rarely need to pay official list price. Because almost every tool speaks the OpenAI-compatible API format, the model provider is just a configuration value — you can route to a cheaper compatible gateway without changing any code.

This guide covers the cheapest, most practical way to access Claude and GPT models in 2026.

Why it works: OpenAI-compatible everywhere

Claude Code, Cursor, Cline, Codex CLI, and the official OpenAI/Anthropic SDKs all talk to an OpenAI-compatible endpoint. That means switching providers is two environment variables:

export OPENAI_BASE_URL="https://api.apivai.com/v1"
export OPENAI_API_KEY="sk-your-key"

The tool doesn't care who is behind the URL, as long as it speaks the standard format.

What to look for in a cheap provider

Factor	Why it matters
Price vs official	The whole point — aim for a large discount on input/output tokens
OpenAI-compatible	Drop-in for existing tools, no rewrite
Streaming passthrough	Token-by-token output must keep working (real SSE, not buffered)
Model coverage	Both Claude and GPT families behind one key
Pay-as-you-go	No subscription; top up and spend down
Payment options	Cards, plus crypto/USDT/Alipay if you can't use a card

How APIVAI fits

APIVAI is an OpenAI- and Anthropic-compatible gateway to Claude and GPT models at a fraction of list price. One key works across models, streaming is proxied as real chunks, and you can pay with crypto, USDT, or Alipay — no VPN, no subscription.

curl https://api.apivai.com/v1/chat/completions \
  -H "Authorization: Bearer $APIVAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"claude-sonnet-4-6","messages":[{"role":"user","content":"Hello"}]}'

Cut costs further

Pick the right model per task — use a smaller/faster model for routine work and reserve the most powerful model for hard problems.
Cache where you can; reuse context instead of resending it.
Watch per-model context limits so you aren't paying for tokens you don't need.

Get started

Create a key, call GET /v1/models to see what's available, set the two environment variables, and send your first request. Your existing tools keep working — just cheaper.

How to Use Continue.dev with a Cheap OpenAI-Compatible API

APIVAI — Thu, 25 Jun 2026 15:45:56 +0000

Use Continue.dev with a cheap OpenAI-compatible API

Continue.dev is a popular open-source AI assistant for VS Code and JetBrains. Like most modern AI coding tools, it speaks the OpenAI-compatible API format — so you don't have to pay official list price. Point it at a cheaper compatible provider and everything works unchanged.

This guide shows the exact Continue config to use an OpenAI-compatible gateway like APIVAI.

Why it works

Continue lets you define any model with a provider: "openai" block and a custom apiBase. That's all it takes to route through a discount gateway — the requests are standard OpenAI chat completions.

Configure Continue

Open your Continue config (~/.continue/config.json, or the YAML config in newer versions) and add a model:

{
  "models": [
    {
      "title": "APIVAI - Claude Sonnet",
      "provider": "openai",
      "model": "claude-sonnet-4-6",
      "apiBase": "https://api.apivai.com/v1",
      "apiKey": "sk-your-apivai-key"
    }
  ]
}

That's it. Reload Continue and the model appears in the dropdown. Send a message to confirm it streams.

Pick a model that exists

Model availability varies, so list what's available first instead of guessing:

curl -s https://api.apivai.com/v1/models \
  -H "Authorization: Bearer $APIVAI_API_KEY"

Use a model name from that response for the model field.

Things to verify

Streaming — Continue streams responses; make sure your provider passes real SSE chunks so output appears token by token.
Model name — must match one the provider serves (avoids model_not_found).
Context window — pick a model whose context fits your codebase chunks.

Why APIVAI

APIVAI is OpenAI- and Anthropic-compatible, covers Claude and GPT models behind one key, and is priced at a fraction of official list. Pay-as-you-go with crypto, USDT, or Alipay, no VPN required — handy if you can't or don't want to use a card.

Get started

Grab a key, drop the config block above into Continue with a model from /v1/models, and start coding at a fraction of the cost — no code changes, same workflow.