The cheapest AI API aggregator in 2026: what $1 of usage really costs on OpenRouter, Requesty, Vercel, Cloudflare and Aight

Every AI API aggregator in this comparison lists the model maker's own per-token prices, and for the models checked here, the input and output prices match exactly. The differences are in what it costs to put money in: a fee on each purchase, a minimum on that fee, card processing, and in one case extra balance added on top.

So the per-token price isn't the useful number. What matters is what $1 of list-price usage costs once the money is in your account. Worked out from each company's own pricing pages, docs and terms on 31 October 2026, paying by card:

• Aight costs $0.936 per $1 of usage, at any purchase size.
• Vercel AI Gateway costs $1.00, plus a card processing fee that Vercel doesn't publish.
• Requesty and Cloudflare AI Gateway cost $1.05.
• OpenRouter and Eden AI cost $1.055. OpenRouter costs $1.16 on a $5 purchase, because its fee has an $0.80 minimum.

On fee math alone, Aight comes out lowest. It isn't the lowest for every workload, though. Batch jobs, open-weight models with many competing hosts, and your own provider keys can all beat it, and its catalog is much smaller than the others'. All of that is covered below. Aight publishes this blog, so the source for every number is listed at the end.

How the numbers are worked out

The measure is simple: what you pay for $1 of usage at list price, where list price means what the model's maker charges per token on its own API.

Cost per $1 = what you pay ÷ the balance you can spend.

A gateway with a 5% purchase fee charges $105 for $100 of balance, so $1 of usage costs $1.05. Aight charges $103 for a $100 recharge (3% processing) and adds $10 extra, so $103 buys $110 of usage: $0.936 per $1.

Three rules keep the comparison fair:

1. It uses the default card payment on the standard self-serve plan. OpenRouter, for example, charges 5% on crypto payments and 8% on its Business plan, but a card purchase on its standard plan pays 5.5%.
2. Only fees published on the company's own pricing page, docs or terms count. Sales tax and VAT are left out for everyone.
3. The rate only means something if the models themselves are billed at list price. The next section checks that.

Do they charge list price for the models?

Yes, on the five models checked. On 31 October, each gateway's public model list or model pages showed the same input and output price as the maker's own pricing page:

Prices are per million tokens, input / output, for each model's global (not region-locked) version. Gemini's price is for prompts up to 200,000 tokens.

Two details are worth checking for your own models. First, Requesty and Eden AI also list region-locked versions of several of these models on Bedrock, Vertex AI and Azure, at 10% to 20% above the global price. For Claude, that's Anthropic's own rule: its pricing page puts a 10% premium on regional and multi-region endpoints. So the region you pick changes the bill, whichever gateway you use. Second, Requesty's model list showed $0.20 per million tokens for cached Claude Sonnet 5.5 input, where Anthropic charges $0.10 for a cache hit. If your traffic relies on prompt caching, compare cache prices too, not just input and output.

Prices move, so check them yourself. OpenRouter and Vercel both publish their catalogs without a key. This prints three models from each, per million tokens:

import json
import urllib.request

def prices(url):
    req = urllib.request.Request(url, headers={"User-Agent": "price-check"})
    with urllib.request.urlopen(req) as r:
        return {m["id"]: m.get("pricing", {}) for m in json.load(r)["data"]}

def per_million(value):
    return f"${float(value) * 1_000_000:.2f}"

openrouter = prices("https://openrouter.ai/api/v1/models")
vercel = prices("https://ai-gateway.vercel.sh/v1/models")

for model in ["anthropic/claude-sonnet-5.5", "openai/gpt-6.1-sol", "google/gemini-3.1-pro-preview"]:
    o, v = openrouter[model], vercel[model]
    print(f"{model:31}",
          f"OpenRouter {per_million(o['prompt'])} / {per_million(o['completion'])}",
          f"Vercel {per_million(v['input'])} / {per_million(v['output'])}")

Requesty (https://router.requesty.ai/v1/models) and Eden AI (https://api.edenai.run/v3/models) publish theirs too, with different field names.

The cost of $1 of usage at $5, $100 and $1,000

Cost per $1 of list-price usage, paying by card on the standard plan.

In dollars, that looks like this:

• Aight: $5.15 buys $5.50 of balance, $103 buys $110, and $1,030 buys $1,100.
• Vercel: $5, $100 or $1,000, plus whatever processing fee checkout shows. Vercel's docs say you're responsible for any payment processing fees but don't give a rate. Enterprise teams can pay by invoice, which has none.
• Requesty: $5.25, $105 and $1,050. Its pricing page describes the 5% as a markup on model cost, while its billing docs add it as a service fee on each purchase. Either way it comes to $1.05 per $1.
• Cloudflare: $105 and $1,050. Its API sets the smallest purchase at $10, which costs $10.50.
• OpenRouter: $5.80, $105.50 and $1,055. The $0.80 minimum fee is more than 5.5% on any purchase below about $14.55, which is why a $5 purchase costs 16% over list.
• Eden AI: $5.28, $105.50 and $1,055.

Put simply, $1,000 of usage at list price costs about $936 on Aight, $1,050 on Requesty or Cloudflare, and $1,055 on OpenRouter or Eden AI. That's $119 less per $1,000 than the highest, or about 11%.

Requesty, Vercel and Eden AI don't publish a minimum purchase, so the $5 column assumes $5 is accepted.

Fees and terms side by side

The fee is only part of the cost. Money that expires, or can't be refunded when you leave, costs you too.

None of the six needs a monthly plan. Each sells a prepaid balance and deducts the cost of every request from it.

Work out your own rate

If your card adds a foreign transaction fee, or a gateway changes its terms, the math is short enough to redo yourself:

def cost_per_dollar(purchase, fee_pct=0.0, min_fee=0.0, extra_pct=0.0, min_purchase=0.0):
    """What $1 of list-price usage costs after the purchase fee and any extra balance."""
    if purchase < min_purchase:
        return None
    paid = purchase + max(purchase * fee_pct, min_fee)
    balance = purchase * (1 + extra_pct)
    return paid / balance

gateways = {
    "Aight (outside India)": dict(fee_pct=0.03, extra_pct=0.10, min_purchase=5),
    "Requesty": dict(fee_pct=0.05),
    "Cloudflare AI Gateway": dict(fee_pct=0.05, min_purchase=10),
    "OpenRouter (card)": dict(fee_pct=0.055, min_fee=0.80, min_purchase=5),
    "Eden AI": dict(fee_pct=0.055),
    "Vercel AI Gateway": dict(fee_pct=0.0),  # add the card processing rate shown at checkout
}

for name, terms in gateways.items():
    rates = [cost_per_dollar(p, **terms) for p in (5, 100, 1000)]
    print(f"{name:22}", "  ".join(f"${r:.3f}" if r else "  n/a " for r in rates))

Which prints:

Aight (outside India)  $0.936  $0.936  $0.936
Requesty               $1.050  $1.050  $1.050
Cloudflare AI Gateway    n/a   $1.050  $1.050
OpenRouter (card)      $1.160  $1.055  $1.055
Eden AI                $1.055  $1.055  $1.055
Vercel AI Gateway      $1.000  $1.000  $1.000

Multiply your expected monthly usage at list price by the rate, and you have the real monthly cost of each option.

When another option costs less

A rate per $1 of list price only helps if you'd be paying list price. Often you don't have to. Here's where something other than Aight comes out lower.

Work that can wait

If a job can run overnight, the makers sell it at half price. OpenAI's and Anthropic's Batch APIs both take 50% off input and output, and Gemini 3.1 Pro Preview's batch rate is $1.00 / $6.00. Several gateways pass that on: OpenRouter and Vercel list batch versions of Claude Sonnet 5.5, GPT-6.1 Sol and other models at half the standard price, and Requesty lists a flex version of GPT-6.1 Sol at $1.00 / $5.00. Aight's documented API has no batch option, so for this kind of work, half price easily beats 6.4% off.

Open-weight models with many hosts

For open-weight models, a router that picks among many hosts can go well below the maker's own price. On 31 October, OpenRouter listed 41 hosts for DeepSeek V4.1 Flash. 25 charged less per output token than the $1.20 per million that DeepSeek charges at peak, and 14 charged less than its $0.60 off-peak price. Many of the low-priced hosts serve 4-bit or 8-bit quantized weights, which OpenRouter shows for each host and which can change output quality, so test before you switch. Aight charges a flat $0.30 / $1.20 for V4.1 Flash, DeepSeek's peak rate, which comes to about $0.28 / $1.12 after the extra.

Your own provider keys

With your own keys (BYOK), the provider bills you directly, at list price or at whatever discount you've negotiated. Vercel adds nothing on top, Cloudflare's pricing page lists no charge for it, and OpenRouter charges nothing on the first $25,000 of list-price usage a month and 5% after that. At list price, that's $1.00 per $1, still above Aight's rate. But if you have a volume discount, startup program money or a committed-spend agreement with a model maker, your own keys keep that benefit, and Aight has no way to use them.

Very small usage

Vercel's free tier includes $5 of usage a month on a subset of models, with lower rate limits. If everything you run fits inside that, it costs nothing. The free amount stops once you make your first purchase.

Models Aight doesn't price at list

The 6.4% only holds where Aight's price matches the maker's. Most of its models do, but not all. Aight lists DeepSeek V4 Pro at $1.74 / $3.48 around the clock, while DeepSeek's own API charges $0.66 / $1.98 off-peak and $1.32 / $3.96 at peak. Compare the models page with the maker's price for the models you actually use.

If you might stop early

Aight spends your paid balance first and the extra last, and the extra isn't refunded. Recharge $100 (paying $103), use $25, then ask for a refund, and you get $77.25 back. That $25 of usage cost $25.75, or $1.03 per $1. The $0.936 rate assumes you use the whole balance, which never expires. For comparison, Requesty, Cloudflare and Eden AI treat purchases as non-refundable, Vercel refunds only if it closes your account without cause, and OpenRouter refunds in the first 24 hours after purchase or when an account is terminated.

Before you use a reseller priced below list

Some services sell access to well-known models at prices below the maker's list, sometimes far below. That can come from legitimate places: committed-spend discounts with a cloud provider, promotional funding, or lower-precision hosting of open-weight models. It can also come from arrangements that don't last. Before production traffic depends on one, get clear answers to these:

1. Where does each model actually run? Ask which company serves it (the maker's own API, a named cloud such as Bedrock, Vertex AI or Azure, or another host), in which region, and whether that provider's terms allow it to be resold.
2. Is it the same model? Check the context window, the maximum output and, for open-weight models, the quantization. Then run a few hundred of your own prompts through it and through the maker's API, and compare.
3. What happens to your prompts? Read the privacy policy and the data processing agreement: whether prompts and outputs are logged, for how long, whether they're used for training, and which subprocessors see them.
4. What happens to your money? Find out whether the prepaid balance is refundable, whether it expires, and what happens to it if the service shuts down or suspends your account.
5. How stable is the price? Look at how often it has changed so far, and how much notice the terms promise before the next change.
6. Start with the smallest purchase, run real traffic for a week, and test the refund process before you rely on it.

A price below list isn't a red flag on its own. A price below list with no answer to the first question is.

Beyond price

Price is one line in the decision. Here's what else each company says on its own pages:

The model count is the clearest gap. If you need a long tail of open-weight or niche models, the larger catalogs have them and Aight doesn't. If you mostly use models from OpenAI, Anthropic, Google, xAI and DeepSeek, 126 is usually enough.

Where Aight fits

Aight is one OpenAI-compatible API for 126 models from 16 makers. It suits teams whose usage is mostly list-priced models from the big makers, such as Claude and GPT, paid from a prepaid US dollar balance. On those models, it works out to 6.4% under list price and about 11% under OpenRouter, at any purchase size from $5.

The terms are part of the price:

• The balance never expires, and there's no subscription or monthly minimum.
• Unspent paid balance can be refunded at any time, at the original rate, including the 3% processing on it. The 10% extra isn't refunded.
• Each key can have a monthly cap, an expiry date and a list of allowed models, so a script can't run past its limit or call a model it shouldn't.
• Aight gives at least 7 days' notice before a price rise and at least 14 days' notice before it removes a model, where the provider allows it, with a named replacement.

It's not the right pick if most of your spend is batch work, a long tail of open-weight models, or traffic on provider keys with negotiated discounts. In those cases, use one of the others, or go direct.

If you already use the OpenAI SDK, switching is two lines:

import os
from openai import OpenAI

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

response = client.chat.completions.create(
    model="claude-sonnet-5-5",
    messages=[{"role": "user", "content": "Summarize this ticket in one line: ..."}],
)
print(response.choices[0].message.content)

The quickstart goes from sign-up to the first request in four steps, and one API key for every major LLM covers setup and per-key limits in more detail. If OpenAI is most of your bill, the cheapest way to use the OpenAI API goes model by model, and OpenAI API key spending limits covers capping what each key can spend.

Sources

• OpenRouter, Pricing (platform fees by plan, BYOK allowance, no minimum spend, per-key caps, in-region routing), FAQ (5.5% fee on card payments with a $0.80 minimum, 5% on crypto, refunds, prompt logging) and Terms of Service (section 4: $5 minimum purchase, 24-hour refund window, expiry after 365 days)
• OpenRouter, models API and DeepSeek V4.1 Flash endpoints (model, batch and per-host prices)
• Requesty, Pricing, Billing docs (5% service fee on each purchase), Bring your own keys, Terms of Service (section 4, no refunds; data retention table) and models API
• Vercel, AI Gateway pricing (no markup, payment processing fees, free tier, BYOK), AI Gateway FAQ (one-year expiry, data handling, spending limits), AI Gateway (model count), Terms of Service and models API
• Cloudflare, Unified Billing and AI Gateway pricing (5% fee, no markup), API reference: create a purchase ($10 minimum), Logging, Spend limits, model catalog and Self-Serve Subscription Agreement (section 4.3)
• Eden AI, Pricing, Plans and pricing docs, Buying and auto-refill docs, Terms (section 3.3) and models API
• Anthropic, Pricing (Claude prices, cache hits, regional endpoint premium, Batch API)
• OpenAI, Pricing; Google, Gemini API pricing; DeepSeek, Models and pricing
• Aight, Models and pricing, API reference, Terms and Refund policy

Checked on 31 October 2026. All prices in US dollars; model prices per million tokens.