DEV Community: APIVAI

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

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.

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.

How to Run Whisper Locally for Real-Time Speech-to-Text (faster-whisper)

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

Run Whisper locally for real-time speech-to-text

For live translation and voice apps, you want speech-to-text that's fast and free per use — which
means running Whisper locally with faster-whisper. It pairs perfectly with APIVAI for the
translation step: Whisper turns audio into text locally, APIVAI (GPT-5.5) translates it cheaply over
an OpenAI-compatible call, and you keep latency low and per-second cost at zero for the audio part.

This guide gets local Whisper running for real-time use.

Install

pip install faster-whisper

faster-whisper is a fast reimplementation of OpenAI's Whisper using CTranslate2. It runs on GPU
(CUDA) or CPU.

Choose a model size

Model	Speed	Accuracy	Use
`tiny` / `base`	fastest	lower	quick captions, weak hardware
`small`	fast	good	recommended for live
`medium`	slower	better	accuracy over speed
`large-v3`	slowest	best	offline/high-accuracy jobs

For live captioning, small on a GPU is the sweet spot.

Transcribe in near real time

from faster_whisper import WhisperModel

model = WhisperModel("small", device="cuda", compute_type="float16")  # device="cpu", compute_type="int8" for CPU

def transcribe(audio_path: str, lang: str = "zh") -> str:
    segments, _ = model.transcribe(audio_path, language=lang, vad_filter=True, beam_size=1)
    return "".join(s.text for s in segments).strip()

Capture short audio chunks (1–3s) from the mic/OBS monitor and feed them in.
vad_filter=True skips silence so you don't transcribe noise.
beam_size=1 favors speed for live use.

Hook it to translation (APIVAI)

from openai import OpenAI
ai = OpenAI(api_key="YOUR_APIVAI_API_KEY", base_url="https://api.apivai.com/v1")

def translate(text, target="Spanish"):
    r = ai.chat.completions.create(model="gpt-5.5", messages=[
        {"role": "system", "content": f"Translate to natural {target}. Output only the translation."},
        {"role": "user", "content": text}])
    return r.choices[0].message.content.strip()

print(translate(transcribe("chunk.wav")))

Performance tips

GPU (float16) is much faster than CPU; on CPU use int8 and a smaller model.
Pre-load the model once and reuse it; don't reload per chunk.
Keep chunks short; longer audio adds latency.

FAQ

Is local Whisper free? Yes — faster-whisper runs on your own hardware; there's no per-call
cost. You only pay for the translation step (e.g. GPT-5.5 via APIVAI), which is cheap.

Does APIVAI provide Whisper? No — APIVAI provides the OpenAI/Anthropic-compatible chat models
(the translation step). Run Whisper locally for speech-to-text.

Which model size for live captions? small on a GPU — a good balance of speed and accuracy.

What latency can I expect? With small + short chunks, transcription is sub-second; end-to-end
(STT → translate → caption) is typically ~1–2s.

Get started

Install faster-whisper, run the transcribe loop, and send the text to APIVAI for translation.
Examples: APIVAI examples repo.

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

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

Build a Discord AI bot with APIVAI

A Discord AI bot lets your server chat with Claude or GPT. Create a bot application, run a small
discord.js script that forwards messages to an OpenAI-compatible model, and reply. APIVAI provides
the model at a fraction of list price, with crypto/USDT/Alipay payment.

1. Create the bot

Go to the Discord Developer Portal → New Application → Bot → copy the bot token.
Enable the Message Content Intent (Bot settings) so the bot can read messages.
Invite the bot to your server (OAuth2 URL with the bot scope and Send Messages permission).

2. The bot (discord.js)

npm install discord.js openai

import { Client, GatewayIntentBits } from "discord.js";
import OpenAI from "openai";

const client = new Client({ intents: [GatewayIntentBits.Guilds, GatewayIntentBits.GuildMessages, GatewayIntentBits.MessageContent] });
const ai = new OpenAI({ apiKey: process.env.APIVAI_API_KEY, baseURL: "https://api.apivai.com/v1" });
const SYSTEM = "You are a helpful assistant in a Discord server. Be concise.";

client.on("messageCreate", async (msg) => {
  if (msg.author.bot) return;
  // respond when mentioned (so the bot isn't noisy)
  if (!msg.mentions.has(client.user)) return;

  const prompt = msg.content.replace(/<@!?\d+>/g, "").trim();
  await msg.channel.sendTyping();
  const r = await ai.chat.completions.create({
    model: "gpt-5.5",
    messages: [{ role: "system", content: SYSTEM }, { role: "user", content: prompt }],
    max_tokens: 500,
  });
  msg.reply(r.choices[0].message.content.slice(0, 1900)); // Discord 2000-char limit
});

client.login(process.env.DISCORD_BOT_TOKEN);

Set DISCORD_BOT_TOKEN and APIVAI_API_KEY, run node bot.js, and mention the bot in your server.

Polish

Add slash commands (/ask) for a cleaner UX.
Keep short per-channel history for context; trim to control token cost.
Split replies over 2000 chars into multiple messages.
Pick GPT-5.5 for general chat, Claude Sonnet for coding help.

FAQ

Can a Discord bot use APIVAI? Yes — it's a standard OpenAI chat call with base URL
https://api.apivai.com/v1; the bot forwards the message and posts the reply.

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

How do I keep it from being spammy? Only respond when mentioned or via a slash command.

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

Get started

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