One API, 160+ models: the case for a unified gateway

The aggregator problem

If you have shipped anything against multiple LLM providers, you have probably reached for an aggregator. One endpoint, many models, one bill. The appeal is obvious: instead of integrating three SDKs and managing three rate limits, you integrate one.

The reality is messier. Aggregators compete on price, and that competition creates incentives that are not always aligned with yours. This article is an honest look at the pain points, and the case for a governed gateway that charges vendor list price with transparent per-token pricing.

Where aggregators break down

• Discounted third-party routes. When a route is cheaper than the vendor list price, something is being cut. It may be a resold key, a proxied account, or a regional route with different guarantees. The price looks good until a route disappears mid-session or a vendor terminates the reseller.
• Model masking. Some aggregators relabel models or route a request to a cheaper equivalent without telling you. You ask for a frontier model and get a distill. The response is plausible, so you may not notice — until the quality regression shows up in your evals and you cannot reproduce it.
• Opaque rate limits. Shared pools mean your traffic competes with every other customer on that key. A burst from someone else throttles you, and the aggregator cannot always tell you why.
• Markup games. "Discounted" pricing often hides a markup on the lanes that matter. The headline is cheap; the frontier models you actually want to call cost more than they should.

None of this is malicious. It is the shape of a market where the product is someone else's API and the only lever is price.

The case for one governed gateway

Riven takes the opposite position. One OpenAI-compatible API at https://api.rivenai.io/v1, 160+ models in the live catalog, one key, one bill. The differences:

• List price, not discounted routes. Standard lanes are a flat $3.00 per 1M tokens. Frontier-class models are billed at vendor list rates with transparent per-token pricing. Kimi K3, for example, ships at Moonshot's published $3 in / $15 out per 1M tokens — the same rate you would pay Moonshot directly.
• No model masking. The model you request is the model that answers. The catalog names each one explicitly, and per-model docs at docs.rivenai.io/docs/model-guides document capabilities and pricing per model.
• Transparent datasheet. Pricing lives at /pricing and matches your invoice. There is no separate "real" rate sheet.
• Drop-in OpenAI SDK. Keep your existing OpenAI SDK code; change base_url and your key.

from openai import OpenAI

client = OpenAI(
    base_url="https://api.rivenai.io/v1",
    api_key="rk_live_...",
)

for m in client.models.list().data:
    print(m.id)

What you give up

A governed gateway at list price is not the cheapest option on paper. If your only criterion is the lowest number per token, a reseller of uncertain provenance will sometimes undercut it. The trade is: you pay list price, and in return the model you call is the model that runs, the route is stable, and the price you see is the price the vendor sets.

For production workloads — where an eval regression or a route outage costs more than tokens — that trade is usually the right one. For throwaway experiments, the cheapest route is fine.

When one gateway wins

One API behind 160+ models is the right choice when any of these are true:

• You switch models often and want one integration, not five.
• You need the model you request to be the model that answers.
• You want pricing you can audit against the vendor's own sheet.
• You want a single usage view across your whole stack.

The live catalog includes Claude Fable 5, GPT-5.6 Sol, Kimi K3, GLM-5.2, DeepSeek V4 Pro, Sonar Reasoning Pro, and Qwen 3.5 397B, among others. You can compare them side by side at /compare/ai.

Get started

Create an account at /sign-up with $0 minimum and $0 to start, or read the docs for the full API and model reference.