TrueFoundry AI Gateway alternative: buying one module of a platform

The Direct Answer: TrueFoundry bundles its AI gateway into a broader MLOps platform metered concurrently across seats and request tiers ($499/mo to $2,999/mo). If you only need model governance, routing, and cost control, you are paying heavy platform seat overhead. nRouter is a purpose-built, standalone AI gateway offering 0% token markup, built-in prompt injection defense, 4-tier budget ceilings, and zero seat taxes.

Figure 1: Self-hosting buys control; the gap teams fill is undifferentiated engineering; the gateway returns that time.

Teams searching for a TrueFoundry alternative are usually not unhappy with the product. They are working out what they bought, or are about to buy.

TrueFoundry's own documentation describes the AI Gateway as a proxy layer in front of the model providers, and lists it alongside a long set of neighbouring capabilities: unified API, multimodal and audio endpoints, load balancing and fallbacks, semantic caching, batch processing, access control and API key management, rate limiting, budget tracking, guardrails, observability, prompt management, an MCP registry, an agent registry and a skills registry. That is a platform. The gateway is a room in it.

Whether that is the right purchase depends on a question no feature table can answer for you: how much of the rest of the building will you actually occupy? The rest of this post is a procedure for answering that, plus the arithmetic that follows from the answer.

The two meters, and why they disagree

TrueFoundry's published plans meter two things at once — request volume and seats:

Overage on Pro is published as an additional $499/month for a further 2M requests and 5 API keys.

There is a third meter neither plan controls, and it is the one that dominates the bill: the provider's own per-token rate. Those are published and they move — Anthropic and AWS Bedrock both post per-million-token prices that differ by an order of magnitude between their small and flagship models. A request allowance is therefore not a spend control at all: a million cheap classification calls and a million long-context reasoning calls consume the same allowance and produce wildly different invoices. Keep that in mind while reading the table above, because it is the reason the two products are not measuring the same thing.

nRouter meters exactly one thing: what you spend on models. nRouter sells one plan, pay as you go, at a 0% platform fee; a credit purchase charges exactly the credits bought ($5 costs $5.00, $100 costs $100.00), nRouter absorbs card-processing costs, and usage settles at the served model's exact list price with 0% markup. There is no seat count, no request allowance, and no key allowance anywhere in it. No subscription plan is sold (existing subscribers keep theirs). Details are on /pricing; the reason a feature never sits behind a plan is argued in Every Feature on Every Plan.

Convert one meter into the other and the contrast becomes obvious. TrueFoundry's Pro subscription charges a flat $499/month alongside request and seat constraints, whereas nRouter charges 0% on top of upstream provider rates. If you only need model routing, governance, and budget enforcement, a fixed $499/month platform fee is an overhead tax on top of your model invoices.

That comparison is only fair if the gateway is all you want. If you are also deploying models, running GPU workloads and using the agent registry, the $499 is buying four or five things and comparing it to a standalone gateway is not an honest comparison. Which is the whole point: decide what you are buying before you compare prices.

Two secondary consequences worth naming, because they surprise people at the wrong moment:

• Seats are a hard number. Three users on Developer, ten on Pro. Governance tools have a way of acquiring viewers — finance wants the spend view, security wants the audit log, a second team lead wants their own budget page. On nRouter, adding a viewer to an org is free, and the org/team/member scoping that makes it safe is described in Org, Team, Member: Scoping Keys, Budgets, Guardrails.
• API keys are counted in the overage line. A per-service or per-customer key strategy multiplies keys deliberately. Check that your intended key hygiene is not a billing event before you design it.

The occupancy test

Answer these five before you compare anything else. Each is a yes or a no.

1. Are you deploying and serving your own models — fine-tuned, open-weights, or classical ML — on infrastructure this vendor manages?
2. Do you need GPU orchestration or autoscaling from the same vendor?
3. Will you use the agent, MCP or skills registries as your team's actual registry, not as a demo?
4. Do you want experiment tracking and model deployment in the same pane as your LLM calls?
5. Is the number of humans who need a login going to stay inside the seat count you are paying for?

Three or more yes: you are buying a platform, the gateway is a bundled convenience, and a standalone gateway would be a second bill for a room you already own. Stay.

One or zero yes: you are buying a gateway and paying platform pricing for it. That is the case this post is written for.

Two yes: price both explicitly, including the seat line, and check what your answer to question 1 will be in twelve months. That answer moves more than the others.

Side-by-side: module versus standalone

TrueFoundry and TrueFoundry AI Gateway are trademarks of TrueFoundry Technologies, Inc. and/or its affiliates. nRouter is not affiliated with or endorsed by TrueFoundry. Every TrueFoundry claim above is sourced from TrueFoundry's own documentation and pricing page on the dates listed in the sources below; if any have changed, email hello@nrouter.ai and we will update the post.

Where the gateway sits, and who can see the traffic

TrueFoundry publishes three deployment shapes: fully managed SaaS across regions, a hybrid mode where the data stays in your own object storage while TrueFoundry operates the gateway, and fully self-hosted in your own cloud or on-premises.

The hybrid mode is the interesting one and it is a genuine advantage. "The vendor runs the control plane, my prompts and completions land in my bucket" is a real answer to a real procurement objection, and it is one we do not have. nRouter is a managed LLM gateway; if your requirement is that request bodies never transit a third party's storage, that requirement is dispositive and you should stay. Our reasoning for taking the managed-only position — and what we think it buys you in exchange — is in Managed LLM Gateway vs Self-Hosted.

The credential question runs the other way. A self-hosted or hybrid gateway is one you configure with your own provider keys, which means your OpenAI, Anthropic and Bedrock credentials sit in your platform configuration and your rotation calendar. nRouter has no bring-your-own-key path at all: one nRouter key and a credit balance, provider credentials on our side. That trade, argued including its downsides, is No BYOK: One nRouter Key Instead of Ten Provider Keys.

Budget enforcement, and the two status codes it produces

"Budget tracking" appears on most gateway feature lists. The distinction worth checking is whether a budget reports or stops, and what your caller sees when it stops — because that determines whether your retry loop makes things better or worse.

On nRouter the ceilings are enforced pre-flight, at four scopes, and they answer with two deliberately different codes:

The split follows the codes' own definitions rather than a house convention. RFC 9110 §15.5.3 reserves 402 Payment Required for the payment case; 429 Too Many Requests comes from RFC 6585 §4, which frames it around a condition that resolves after a wait. Any HTTP client that already distinguishes them behaves correctly here before you write a line of handling.

The split is not cosmetic. A 402 means the money is gone and retrying is pointless until someone raises a ceiling or adds credit. A 429 on a key budget means this key is done for the window while the rest of the org is fine, so a caller can fail over to a different key or shed that workload without taking the whole service down. Getting that wrong turns a spent budget into a retry storm — the full treatment is in 429 vs 402 on an LLM Gateway, and the four ceilings are configured as described at /docs/guides/budget-controls and walked through in Hard LLM Spend Caps at Org, Team, User, and Key Scope.

The same pre-flight discipline applies to cost reporting: when a call's cost cannot be determined, x-nr-request-cost is absent from the response and x-nr-cost-status reads unpriced. It is never reported as zero, for the reason in Cost Honesty.

What TrueFoundry genuinely does better

It serves your own models. This is the whole ballgame and it is not close. If you fine-tune, if you run open-weights models on your own GPUs, if you have classical ML in production, TrueFoundry deploys and scales those. nRouter routes to a catalog of hosted models — see /models — and has no story at all for a checkpoint you trained last week. A team with both workloads is choosing between one vendor for everything and two vendors with a clean seam.

It has a $0 entry tier. Developer is 50k requests and three users for nothing. nRouter offers eligible new accounts promotional trial credits with verification and spending limits. Paid pay-as-you-go usage starts with a $5 credit purchase on a card. Compare those trial limits with Developer's request allowance before choosing an evaluation plan.

The registries are ahead of us. Agent, MCP and skills registries are shipped surfaces there. If your team is standardizing how agents discover tools, that is a real capability sitting in the same product as your gateway.

Data residency options. Covered above, and worth repeating here because it belongs on this list as much as on that one.

Switch cost: one base URL, one key

Both sides are OpenAI-compatible, so the code change is two lines:

  from openai import OpenAI

  client = OpenAI(
-     base_url="https://<your-truefoundry-host>/api/llm",
-     api_key=os.environ["TFY_API_KEY"],
+     base_url="https://api.nrouter.ai/v1",
+     api_key=os.environ["NROUTER_API_KEY"],
  )

  resp = client.chat.completions.create(
-     model="openai-main/gpt-5.5",
+     model="gpt-5-mini",
      messages=[{"role": "user", "content": "summarise this ticket"}],
  )

The line that is easy to miss is the third one. Platform gateways commonly namespace a model by the provider account it was configured under, so the model string in your code encodes a piece of that platform's configuration. On nRouter the model string is the model — gpt-5-mini, gpt-5.4, claude-haiku-4-5-20251001, o3 — and the mapping to a provider account is not your concern. Grep your codebase for the namespaced form before you plan the migration; it is usually in more places than anyone expects, including prompt templates and eval fixtures.

What maps, and what does not

Four rows say the migration is partial. If those four rows are the ones you use, the migration is not partial — it is wrong, and the next section is the one that applies.

The renewal test, and when to stay

Here is the question to ask at renewal, or before signing: if you removed the gateway from this contract, would the rest still be worth the price?

If yes, stay on TrueFoundry and stop reading — the gateway is riding along on a purchase you would make anyway, and splitting it out buys you a second vendor relationship for no gain.

If no — if the honest answer is that the gateway is most of the value and the platform is the wrapper it arrived in — then you are paying a platform price for a gateway, bounded by seats and requests you did not choose to meter. That is the case where a standalone gateway is simply the cheaper and simpler purchase: priced on model spend, no seat ceiling, no request allowance, every governance surface available on the plan you are already on.

Stay on TrueFoundry if own-model serving is live in production, if hybrid or self-hosted deployment is a compliance requirement rather than a preference, if the registries are load-bearing for how your agents find tools, or if semantic caching is already paying for itself. Those are good reasons and none of them are solved by switching.

Try it

Before choosing a gateway entry plan, eligible new accounts can receive $100 in promotional credits after email and phone verification, without a card. Promotional access has a restricted model set and spending limits; see current pricing and promotion terms.

Pay as you go starts at $5 — a card is required, and a purchase charges exactly the credits bought ($5 costs $5.00). Promotional credits have separate eligibility and spending limits.

→ Create an account, mint a key, and run one workload against https://api.nrouter.ai/v1 alongside your existing gateway. Compare the bill for that workload against the request and seat lines on your current plan.

Bring your plan tier, your seat count and your model bill to a walk-through and we will run the occupancy test above with you. Questions go to hello@nrouter.ai or the public nRouter Slack.

See also

• Managed LLM Gateway vs Self-Hosted: Why We Carry the Pager — the deployment trade in full, including when hybrid or self-hosted wins.
• Every Feature on Every Plan: No Fee, No Gate — why nothing here is bounded by seats, requests or plan tier.
• Org, Team, Member: Scoping Keys, Budgets, Guardrails — the scoping model that replaces seat management.
• Hard LLM Spend Caps at Org, Team, User, and Key Scope — how the four ceilings are set and what each one stops.
• 429 vs 402 on an LLM Gateway — the retry logic that has to change once budgets actually stop calls.
• Four Outcomes That Get an LLM Gateway Funded — useful if the platform-versus-point-tool argument is happening in a budget meeting.
• Pricing — pay as you go details and the 0% platform fee.

Sources

Verified 2026-08-23. Every TrueFoundry claim traces to TrueFoundry's own documentation or pricing page. If a page has changed since, email hello@nrouter.ai and we will re-audit and re-date this section.

• TrueFoundry AI Gateway overview — proxy layer, deployment modes, feature areas: truefoundry.com/docs/gateway/intro-to-llm-gateway
• TrueFoundry pricing — Developer $0 / Pro $499 / Pro Plus $2,999 / Enterprise, request and seat allowances, overage line: truefoundry.com/pricing
• TrueFoundry documentation: truefoundry.com/docs
• Anthropic pricing — published per-million-token rates, cited for the third-meter argument: anthropic.com/pricing
• AWS Bedrock pricing — the same, for a provider that is live on nRouter: aws.amazon.com/bedrock/pricing
• RFC 9110 §15.5.3, 402 Payment Required: datatracker.ietf.org/doc/html/rfc9110 — the semantics behind the org, team and user refusal.
• RFC 6585 §4, 429 Too Many Requests: datatracker.ietf.org/doc/html/rfc6585 — the semantics behind the per-key refusal.
• nRouter pricing: /pricing
• nRouter model catalog: /models

TrueFoundry, Anthropic and AWS are trademarks of their respective owners. nRouter is not affiliated with or endorsed by them.