DEV Community: APIVAI

How to Use Cursor with a Cheap AI API (Save 90%)

APIVAI — Wed, 10 Jun 2026 17:38:05 +0000

Cursor + Cheap AI API = Best Developer Experience

Cursor is one of the most popular AI-powered IDEs. It supports custom API endpoints, which means you can route requests through a cheaper provider.

Why Use a Custom API?

Option	Cost	Limitation
Cursor Pro	$20/month	Rate limited
Cursor + Official API	$3-5/M tokens	Expensive at scale
Cursor + APIVAI	$0.77/M tokens	No limits, 90% cheaper

Setup in 2 Minutes

Step 1: Get Your API Key

Sign up at apivai.com
Top up your balance ($10 minimum)
Copy your API key from the dashboard

Step 2: Configure Cursor

Open Cursor Settings (Cmd+, or Ctrl+,)
Go to Models section
Set Override OpenAI Base URL to:

https://api.apivai.com/v1

Set your API Key to your APIVAI key

Step 3: Select Your Model

Choose from:

claude-sonnet-4-6-20250514 — Best balance (recommended)
claude-opus-4-7-20250416 — Most powerful
claude-haiku-4-5-20251001 — Fastest, cheapest
gpt-5.4 — OpenAI alternative

Cost Savings Example

A typical Cursor power user might make 50-100 AI requests per day:

Requests/day	Cursor Pro	APIVAI API	Monthly Savings
50	$20/mo (limited)	~$4/mo	$16
100	$20/mo (heavily limited)	~$8/mo	$12 + no limits
200+	Not possible	~$16/mo	Unlimited

With APIVAI, you get unlimited requests — no rate limiting, no throttling.

Also Works With

VS Code + Continue extension
Neovim + avante.nvim
JetBrains + AI Assistant
Any tool that supports OpenAI-compatible APIs

Get Started

How to Set Up Claude Code with a Cheap API Provider

APIVAI — Wed, 10 Jun 2026 17:32:39 +0000

What is Claude Code?

Claude Code is Anthropic's official CLI tool that lets you use Claude directly in your terminal. It's incredibly powerful for coding, debugging, and automating development tasks.

The problem? It uses the Anthropic API, which means you're paying $3/$15 per million tokens for Sonnet, or $5/$25 for Opus.

The Solution: Use a Cheaper API Provider

Instead of connecting directly to Anthropic, you can route Claude Code through APIVAI — an API gateway that offers the same models at up to 90% off.

What changes: One environment variable (the base URL)
What stays the same: Everything else — same models, same quality, same features

Setup Guide

Prerequisites

Claude Code installed (npm install -g @anthropic-ai/claude-code)
A APIVAI account (sign up here)
An API key from your APIVAI dashboard

Mac / Linux

Add these to your ~/.bashrc or ~/.zshrc for permanent setup:

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

Then run:

source ~/.bashrc  # or source ~/.zshrc
claude

Windows PowerShell

Add to your PowerShell profile ($PROFILE):

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

Then just run claude.

One-liner (temporary)

Mac/Linux:

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

PowerShell:

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

Also Works With Codex CLI

Since Codex 0.121+, you need a config file:

mkdir -p ~/.codex && cat > ~/.codex/config.toml << 'EOF'
model = "gpt-5.3-codex"
model_provider = "apivai"

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

Then run:

OPENAI_API_KEY="your-apivai-key" codex

Available Models

Model	Best For
Claude Opus 4.7	Most complex tasks, research
Claude Opus 4.6	Complex coding, analysis
Claude Sonnet 4.6	Best balance of speed and quality
Claude Haiku 4.5	Fast tasks, simple queries
GPT-5.4	Alternative perspective
GPT-5.3 Codex	Code generation

Cost Comparison

Daily Usage	Official API	APIVAI	Monthly Savings
Light (10 msgs/day)	~$6/mo	~$1.20/mo	$4.80
Medium (30 msgs/day)	~$18/mo	~$3.60/mo	$14.40
Heavy (100 msgs/day)	~$60/mo	~$12/mo	$48

Troubleshooting

"Unauthorized" error: Make sure your API key starts with sk-ant- and has sufficient balance.

"Connection refused": Check that ANTHROPIC_BASE_URL is set to https://api.apivai.com (no trailing slash, no /v1).

Slow responses: First request may be slower due to prompt caching. Subsequent requests are faster.

Get Started

Sign up at apivai.com
Top up your balance (minimum $10)
Copy your API key from the dashboard
Set the environment variables and run claude

That's it. Same Claude Code, 90% cheaper.

5 Best Cheap Claude API Alternatives in 2026

APIVAI — Wed, 10 Jun 2026 17:32:35 +0000

Why Look for Claude API Alternatives?

Anthropic's official Claude API pricing is steep:

Model	Official Input	Official Output
Claude Opus 4.7	$5/M tokens	$25/M tokens
Claude Sonnet 4.6	$3/M tokens	$15/M tokens
Claude Haiku 4.5	$1/M tokens	$5/M tokens

For developers and startups, these costs add up quickly. A typical Claude Code session can burn through $5-10 per day. Here are the best alternatives.

1. APIVAI — Best Overall (Up to 90% Off)

Pricing: From $0.77/M input, $3.86/M output (Sonnet 4.6)

APIVAI is an API gateway that provides access to all Claude and GPT models through a single OpenAI-compatible API:

Drop-in replacement — change one URL
Works with Claude Code, Cursor, Codex CLI
Pay per token, no subscription
No VPN needed, no region restrictions
Supports Claude Opus 4.7, 4.6, Sonnet 4.6, Haiku 4.5, GPT-5.4

# Claude Code setup
ANTHROPIC_AUTH_TOKEN="your-key" \
ANTHROPIC_BASE_URL="https://api.apivai.com" \
claude

Best for: Developers who want the cheapest Claude API access with zero setup friction.

2. OpenRouter

Pricing: Close to official rates (small markup)

OpenRouter aggregates multiple AI providers but prices are typically only 5-10% below official. Good selection of models but not the cheapest option.

Best for: Users who need access to many different providers.

3. AWS Bedrock

Pricing: Similar to official, volume discounts available

Amazon Bedrock offers Claude models with enterprise features. Requires AWS account setup and IAM configuration. Not ideal for individual developers.

Best for: Enterprise teams already on AWS.

4. Google Cloud Vertex AI

Pricing: Pay-as-you-go, competitive for high volume

Vertex AI provides Claude models through Google Cloud. Complex setup, requires GCP account.

Best for: Teams using Google Cloud infrastructure.

5. Direct Anthropic API with Prompt Caching

Pricing: Official rates, but 90% off cached tokens

Using Anthropic's prompt caching can reduce costs significantly for repetitive workloads, but only helps with cache-eligible tokens.

Best for: Specific use cases with highly repetitive prompts.

Price Comparison Table

Provider	Sonnet Input	Sonnet Output	Setup
Anthropic (Official)	$3.00	$15.00	Credit card, region limited
APIVAI	$0.77	$3.86	Email signup, crypto payment
OpenRouter	$2.85	$14.25	Account required
AWS Bedrock	$3.00	$15.00	AWS account + IAM

Verdict

For most developers, APIVAI offers the best value — same models, same quality, up to 90% cheaper. No complex cloud setup, no subscription, and it works as a drop-in replacement for any tool that supports OpenAI or Anthropic APIs.

Get started at apivai.com →

How to Use Claude Code and GPT API at 90% Off

APIVAI — Wed, 10 Jun 2026 17:27:05 +0000

The Problem: AI APIs Are Expensive

If you're a developer using Claude Code, Cursor, or building with AI APIs, you know the costs add up fast:

Service	Cost	Limitation
Claude Pro	$20/month	Rate limited, no API access
Anthropic API (Sonnet)	$3/$15 per M tokens	Requires credit card, region restrictions
OpenAI API (GPT-5.4)	$3/$10 per M tokens	Same issues
APIVAI	$0.69/$3.43 per M tokens	No subscription, no restrictions

That's a 77% savings on Claude Sonnet alone.

What is APIVAI?

APIVAI is an AI API gateway that gives you access to the same Claude and GPT models through a single, OpenAI-compatible API:

All models, one API key — Claude Opus 4.7, Opus 4.6, Sonnet 4.6, Haiku 4.5, GPT-5.4, GPT-5.3 Codex
90% cheaper than official API pricing
No subscription — pay per token, starting from $10
No VPN needed — works from anywhere
Drop-in replacement — change one URL, everything else stays the same

How to Use with Claude Code

Just set two environment variables:

Mac/Linux:

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

Windows PowerShell:

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

Same Claude Code experience, 90% cheaper.

How to Use with Cursor

Go to Cursor Settings > Models > Override OpenAI Base URL and set:

https://api.apivai.com/v1

Real Cost Comparison

Usage Pattern	Official API	APIVAI	Savings
Casual (50 msgs/mo)	$1.75	$0.35	80%
Daily user (20 msgs/day)	$12.25	$2.45	80%
Developer (10M tokens/mo)	$45+	$9	80%

No monthly fee. Pay only for what you use.

API Compatibility

Works with any OpenAI-compatible tool: Claude Code, Cursor, Continue, Aider, Open Interpreter, and more.

from openai import OpenAI
client = OpenAI(
    api_key="your-apivai-key",
    base_url="https://api.apivai.com/v1"
)
response = client.chat.completions.create(
    model="claude-sonnet-4-6-20250514",
    messages=[{"role": "user", "content": "Hello!"}]
)

Get Started

Sign up at apivai.com — email + verification code
Top up — starting from $10 via cryptocurrency
Set your base URL to api.apivai.com and start coding

No subscription. No VPN. No restrictions.

How to Use APIVAI as an OpenAI-Compatible API Gateway

APIVAI — Wed, 10 Jun 2026 17:27:01 +0000

Introduction

Many developer tools, command-line utilities, and AI applications support OpenAI-compatible endpoints. APIVAI provides a gateway-style API experience that lets developers test and integrate AI models through familiar request patterns without rewriting every client from scratch.

This guide focuses on practical integration details: OpenAI-compatible request structure, /v1/models, /v1/chat/completions, API key authentication, Python, Node.js, cURL examples, streaming responses, and configuration notes for Claude Code and Cursor.

What is an OpenAI-compatible API gateway?

An OpenAI-compatible API gateway exposes request and response patterns that are familiar to developers who have used OpenAI-style APIs. The most important pieces are a base URL, Bearer token authentication, JSON request bodies, a model field, a messages array, response choices, and optional streaming.

For APIVAI, the default OpenAI-compatible base URL is:

https://api.apivai.com/v1

Compatibility can vary by client and feature. Treat the gateway as a developer-friendly integration layer, then test the specific models, parameters, and tools your application depends on.

When should developers use APIVAI?

Use APIVAI when you want to test OpenAI-compatible request flows, connect local scripts, try Python, Node.js, or cURL examples, configure tools that support custom OpenAI-compatible base URLs, or check model availability before hardcoding model names.

It is also useful when you want a cost-effective API gateway for development workflows while keeping your application code close to standard OpenAI-compatible patterns.

Basic environment variables

For macOS and Linux:

export APIVAI_API_KEY="YOUR_APIVAI_API_KEY"
export APIVAI_BASE_URL="https://api.apivai.com/v1"
export APIVAI_MODEL="YOUR_MODEL_NAME"

For PowerShell:

$env:APIVAI_API_KEY="YOUR_APIVAI_API_KEY"
$env:APIVAI_BASE_URL="https://api.apivai.com/v1"
$env:APIVAI_MODEL="YOUR_MODEL_NAME"

Keep your API key outside source control. Use environment variables, a local secret manager, or your deployment platform's secret store.

Discover available models

Before hardcoding a model name, call /v1/models and inspect the response. This helps avoid configuration drift when a client, model alias, or provider-side availability changes.

curl "$APIVAI_BASE_URL/models" \
  -H "Authorization: Bearer $APIVAI_API_KEY"

A typical response includes a data array. Choose a model ID from that list and set it as APIVAI_MODEL.

Send a chat completion with cURL

curl "$APIVAI_BASE_URL/chat/completions" \
  -H "Authorization: Bearer $APIVAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "'"$APIVAI_MODEL"'",
    "messages": [
      { "role": "system", "content": "You are a concise developer assistant." },
      { "role": "user", "content": "Explain API gateway routing in one paragraph." }
    ]
  }'

If the request succeeds, read choices[0].message.content from the JSON response.

Python example

The OpenAI Python SDK can be pointed at APIVAI by changing the base_url.

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["APIVAI_API_KEY"],
    base_url=os.environ.get("APIVAI_BASE_URL", "https://api.apivai.com/v1"),
)

response = client.chat.completions.create(
    model=os.environ["APIVAI_MODEL"],
    messages=[
        {"role": "system", "content": "You write clear developer documentation."},
        {"role": "user", "content": "Give me a short API gateway checklist."},
    ],
)

print(response.choices[0].message.content)

Node.js example

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.APIVAI_API_KEY,
  baseURL: process.env.APIVAI_BASE_URL || "https://api.apivai.com/v1",
});

const response = await client.chat.completions.create({
  model: process.env.APIVAI_MODEL,
  messages: [
    { role: "system", content: "You are a practical coding assistant." },
    { role: "user", content: "Write a small JSON API testing checklist." },
  ],
});

console.log(response.choices[0].message.content);

Streaming example

Streaming is useful for CLIs, chat interfaces, and tools that should display tokens as they arrive. Enable stream: true and iterate over chunks.

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["APIVAI_API_KEY"],
    base_url=os.environ.get("APIVAI_BASE_URL", "https://api.apivai.com/v1"),
)

stream = client.chat.completions.create(
    model=os.environ["APIVAI_MODEL"],
    messages=[{"role": "user", "content": "Stream three API debugging tips."}],
    stream=True,
)

for chunk in stream:
    delta = chunk.choices[0].delta.content
    if delta:
        print(delta, end="", flush=True)

Claude Code configuration notes

Claude Code primarily expects Anthropic-style configuration. Some gateway setups expose Claude-compatible routes separately from OpenAI-compatible routes, so verify the current APIVAI dashboard or documentation before assuming a single base URL works for every client.

For Claude Code, the common pattern is to set an auth token and base URL for the CLI, then run a small test prompt:

export ANTHROPIC_AUTH_TOKEN="YOUR_APIVAI_API_KEY"
export ANTHROPIC_BASE_URL="https://api.apivai.com"
claude

If your Claude Code version changes its provider configuration format, prefer the official client configuration mechanism and keep APIVAI as the custom endpoint.

Cursor configuration notes

Cursor and similar editors may allow a custom OpenAI-compatible base URL. Use:

https://api.apivai.com/v1

Then set your APIVAI API key in the tool's API key field and choose a model that appears in /v1/models. If a specific model does not appear in the editor UI, test it first with cURL or a small script before relying on it in daily coding work.

Troubleshooting

If you receive 401 Unauthorized, check that the Authorization header is exactly Bearer YOUR_APIVAI_API_KEY, the key has not been pasted with spaces, and the environment variable is loaded in the shell running your script.

If you receive 404 Not Found, confirm that your base URL includes /v1 for OpenAI-compatible calls and that the path is /chat/completions or /models.

If you receive a model error, call /v1/models again and copy the exact model ID from the response. Avoid guessing model names from older examples.

If streaming does not render in your tool, test the same request without stream: true. Some clients buffer streamed output or require a separate streaming parser.

If a third-party tool behaves differently from your script, compare the exact base URL, headers, model name, and JSON body. Small differences such as a missing /v1 or an unsupported parameter can change the result.

Integration checklist

Start with /v1/models, choose a model ID, run a non-streaming /v1/chat/completions request, add streaming only after the basic request works, and then configure your editor or CLI.

This approach keeps the first integration small and observable. Once the request path, authentication, and model selection are working, you can move the same pattern into a larger application.

How to Cut Your Claude API Costs (Without Switching Models)

APIVAI — Wed, 10 Jun 2026 17:21:27 +0000

Where Claude API costs actually go

Most large Claude bills are not caused by the model choice alone — they come from sending more tokens than necessary, on a more expensive model than the task needs, without caching anything. Before switching providers, it is worth fixing the parts you control. This guide walks through practical ways to cut Claude (and GPT) API costs, then where a discount gateway fits in.

1. Match the model to the task

Opus-class models are worth it for hard reasoning and agentic work, but a lot of real traffic — classification, extraction, short rewrites, routing — runs fine on a smaller, much cheaper model. A common pattern is to route easy requests to a cheap model and only escalate to a frontier model when needed.

Task	Reasonable model tier
Classification, routing, extraction	Cheapest (Haiku-class)
General chat, summaries, drafts	Mid (Sonnet-class)
Hard reasoning, agents, long context	Frontier (Opus-class)

2. Use prompt caching for repeated context

If you send the same large system prompt, instructions, or document on every call, prompt caching lets the provider reuse that prefix at a large discount instead of re-billing it each time. Put the stable content first and the variable user input last, so the cacheable prefix stays identical across requests. For agents and RAG that resend the same context repeatedly, this is often the single biggest saving.

3. Trim tokens you are paying for

Shorten bloated system prompts — every request pays for them.
Cap max_tokens to what the task needs instead of leaving a huge ceiling.
Summarize or window long chat history rather than resending the entire transcript.
Strip boilerplate from retrieved documents before adding them to context.

4. Stream to cut perceived cost, not real cost

Streaming does not reduce token cost, but it improves responsiveness, which lets you use a cheaper model without the UX feeling slow. That can let you downgrade a tier for interactive features.

5. Use a discounted, OpenAI-compatible gateway

After you have optimized usage, the remaining lever is the per-token price itself. A gateway like APIVAI resells Claude and GPT models at a steep discount off official pricing behind an OpenAI- and Anthropic-compatible API, so you keep all of the optimizations above and simply lower the unit price. It drops into existing code with a base-URL and key change.

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

A simple cost checklist

Route easy work to the cheapest capable model.
Cache stable prompt prefixes.
Cap max_tokens and trim history and documents.
Measure real token usage before and after each change.
Lower the unit price with a discount gateway once usage is tight.

Get started

Pick one of these levers and measure the difference on your real traffic. If you want the unit-price win with no code rewrite, create an APIVAI key, point your OpenAI-compatible client at the APIVAI base URL, and choose a model from /v1/models.

Using an OpenAI-Compatible API with n8n, LangChain & LlamaIndex

APIVAI — Wed, 10 Jun 2026 17:21:23 +0000

One base URL change, three frameworks

n8n, LangChain, and LlamaIndex all speak the OpenAI-compatible API. That means you can point them at any OpenAI-compatible gateway by changing the base URL and API key — no custom integration code. This guide shows the exact setting in each, using APIVAI (which resells Claude and GPT at a steep discount) as the endpoint.

The APIVAI base URL is https://api.apivai.com/v1. Pick a model from /v1/models before hardcoding a name.

n8n

In n8n, the OpenAI nodes (and the AI Agent / Chat Model nodes) accept a custom credential. Create an "OpenAI" credential and set:

API Key: your APIVAI key
Base URL: https://api.apivai.com/v1

Then choose a model ID returned by /v1/models in the node. Existing n8n OpenAI nodes and agent workflows keep working — only the credential changed. This is the fastest way to run cheaper models inside automation flows.

LangChain (Python)

LangChain's ChatOpenAI takes a base_url and api_key. Set them and you are done.

from langchain_openai import ChatOpenAI
llm = ChatOpenAI(base_url="https://api.apivai.com/v1", api_key="YOUR_APIVAI_API_KEY", model="claude-sonnet-4-6")
print(llm.invoke("Write one sentence about API gateways.").content)

The same pattern works for chains, agents, and tool calling — anything built on ChatOpenAI inherits the endpoint.

LangChain (JavaScript)

import { ChatOpenAI } from "@langchain/openai";
const llm = new ChatOpenAI({ model: "claude-sonnet-4-6", apiKey: "YOUR_APIVAI_API_KEY", configuration: { baseURL: "https://api.apivai.com/v1" } });
const res = await llm.invoke("Write one sentence about API gateways.");
console.log(res.content);

LlamaIndex (Python)

LlamaIndex's OpenAI-compatible LLM wrapper accepts an api_base.

from llama_index.llms.openai_like import OpenAILike
llm = OpenAILike(model="claude-sonnet-4-6", api_base="https://api.apivai.com/v1", api_key="YOUR_APIVAI_API_KEY", is_chat_model=True)
print(llm.complete("Write one sentence about API gateways."))

Verify before you build

Whatever framework you use, run a tiny request first to confirm the endpoint, key, and model are wired correctly. A 401 means the key is not being read; a 404 usually means the base URL is missing /v1; a model error means the configured name is not in the current /v1/models response.

Get started

Create an APIVAI key, drop the base URL into your n8n credential or your ChatOpenAI / OpenAILike config, pick a model from /v1/models, and your existing framework code runs against cheaper models with no rewrite.

Best Cheap API for Cline, Aider & Roo Code (Save 90%)

APIVAI — Wed, 10 Jun 2026 17:14:14 +0000

Agentic coding tools are token-hungry

Cline, Aider, and Roo Code are excellent at multi-step edits, but agentic coding sends a lot of tokens — reading files, planning, retrying, and re-sending context. On official pricing that adds up fast. All three accept a custom OpenAI- or Anthropic-compatible endpoint, so you can route them through a discount gateway like APIVAI and keep the same workflow at a lower unit price.

The APIVAI base URL is https://api.apivai.com/v1. List models with /v1/models and pick one before configuring.

Cline (VS Code)

Cline supports an OpenAI-compatible provider in its settings:

API Provider: OpenAI Compatible
Base URL: https://api.apivai.com/v1
API Key: your APIVAI key
Model: an ID from /v1/models

Cline also works with Anthropic-style models; if you select an Anthropic provider, use the APIVAI endpoint and a Claude model ID. Start with a small task to confirm routing before a large refactor.

Aider (CLI)

Aider reads an OpenAI-compatible base URL and key from environment variables.

export OPENAI_API_BASE="https://api.apivai.com/v1"
export OPENAI_API_KEY="YOUR_APIVAI_API_KEY"
aider --model claude-sonnet-4-6

For Claude models, Aider routes them through the same OpenAI-compatible base URL when configured this way. Use a cheaper model for routine edits and escalate only when a change is hard.

Roo Code (VS Code)

Roo Code (a Cline fork) uses the same idea: choose the OpenAI Compatible provider, set the base URL to https://api.apivai.com/v1, paste your APIVAI key, and pick a model from /v1/models. Your existing Roo workflows and modes are unchanged.

Tips to keep agent costs down

Start agents on a mid or cheap model; only switch to a frontier model for genuinely hard steps.
Keep the working context tight — fewer files in context means fewer tokens per step.
Confirm the endpoint with a one-line task before letting an agent run a long plan.

Troubleshooting

401: the key is missing or not saved in the tool's settings.
404: the base URL is missing /v1 or includes it twice.
Model error: the configured model is not in the current /v1/models list — pick a returned ID.

Get started

Create an APIVAI key, set the OpenAI-compatible base URL in Cline, Aider, or Roo Code, choose a model from /v1/models, and run a small task. The same agent workflow now runs at a lower per-token cost.

How to Pay for AI APIs with Crypto, USDT, or No Credit Card

APIVAI — Wed, 10 Jun 2026 17:14:11 +0000

Why pay for an AI API without a credit card

A lot of developers cannot — or would rather not — put a credit card on a US AI provider. Cards get declined across borders, some regions are not supported, prepaid cards are rejected, and many people simply prefer not to attach a card to a metered service that could run up a bill. Paying with crypto, USDT, or a local method solves all of these while still giving you Claude and GPT access.

This guide explains the options and how to start with APIVAI, which accepts crypto, USDT, and Alipay alongside cards.

The options, compared

Method	Card needed?	Good for
Crypto / USDT	No	Global access, privacy, no card declines
Alipay	No	Users in regions where Alipay is common
Credit card	Yes	Users who already have a supported card

Why crypto and USDT work well here

No card declines or cross-border rejections — it works the same everywhere.
Prepaid and pay-as-you-go by nature: you top up a balance and spend it down, so there is no surprise monthly charge.
USDT (a dollar-pegged stablecoin) keeps the amount predictable, unlike volatile coins.
Less personal payment information attached to your usage.

How to top up with crypto on APIVAI

Create an account and get your API key.
Open the balance / top-up page.
Choose the crypto or USDT option and pay to the address shown.
Once confirmed, your balance is credited and usable immediately.

Your balance then works across every model behind one OpenAI- and Anthropic-compatible API. There is no subscription — you only spend what you top up.

Using the balance

After topping up, point any OpenAI-compatible client at the APIVAI base URL and send a request. The same key works for Claude and GPT models, in your own code, Cursor, Claude Code, Codex CLI, and agent tools.

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"}]}'

Get started

If a card is the only thing standing between you and Claude or GPT access, top up with crypto, USDT, or Alipay instead. Create a key, add a small balance, pick a model from /v1/models, and send your first request — no card required.

How to Use Codex CLI with a Cheap GPT API (Save 90%)

APIVAI — Wed, 10 Jun 2026 16:59:34 +0000

Use Codex CLI without paying full price

OpenAI's Codex CLI is a fast way to edit code, run commands, and pair with a model directly from your terminal. The friction is cost: pointed at official endpoints, a busy day of agentic coding adds up quickly. The good news is that Codex CLI talks to an OpenAI-compatible endpoint, so you can route it through a cheaper gateway with a one-line change and keep the exact same workflow.

This guide shows how to configure Codex CLI to use APIVAI, which resells GPT and Claude models at a steep discount off official pricing.

What you need

Codex CLI installed and working.
An APIVAI API key.
The APIVAI base URL: https://api.apivai.com/v1.

Step 1 — point Codex at the APIVAI endpoint

Codex CLI reads an OpenAI-style base URL and API key from environment variables. Set them in the shell that launches Codex.

export OPENAI_BASE_URL="https://api.apivai.com/v1"
export OPENAI_API_KEY="YOUR_APIVAI_API_KEY"

On Windows PowerShell:

$env:OPENAI_BASE_URL="https://api.apivai.com/v1"
$env:OPENAI_API_KEY="YOUR_APIVAI_API_KEY"

That is the whole change. Codex now sends its requests to APIVAI instead of the default endpoint, and your existing prompts, approvals, and file edits behave the same.

Step 2 — pick a model

Before hardcoding a model name, list what your account can use and choose one from the response.

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

Set the model Codex should use to one of the returned IDs, for example a GPT-class model for general coding. APIVAI exposes the OpenAI Responses API that Codex relies on, so tool calls and streaming work as expected.

Step 3 — run a small task first

Start with a tiny, low-risk request to confirm routing before turning Codex loose on a real change.

codex "explain what this repo does in two sentences"

If you get a normal response, the endpoint, key, and model are all wired correctly. From here, use Codex exactly as you would against the official API.

Why route Codex through APIVAI

Lower effective cost on GPT and Claude models, with no subscription.
One OpenAI-compatible key that also works with Cursor, Claude Code, and your own scripts.
Pay-as-you-go top-ups, including crypto and Alipay.
Model discovery via /v1/models so you avoid stale, hardcoded model names.

Troubleshooting

A 401 usually means the key is missing or not exported in the shell that launched Codex.
A 404 often means the base URL is missing /v1 or has it twice.
A model error means the configured model is not in the current /v1/models response — pick a returned ID.
If streaming looks stuck, confirm the client reads the response incrementally and retry a non-streaming request to isolate the issue.

Get started

Create an API key, export the two environment variables above, choose a model from /v1/models, and run a small Codex task to confirm everything works. Most existing OpenAI-compatible setups need only the base-URL and key change.