Run the gates in this order on every request: wallet aggregate, reserve, committed cap, then alias subcap. If the aggregate would be exceeded, deny before routing and record the denial reason; do not fall through to another alias until the aggregate is rechecked. Any exception should be a logged override rather than a silent retry.
Reconcile committed spend against wallet_remaining before the next request. A stale balance can make a closed alias look available, while the aggregate check prevents that alias from reopening the wallet. Keep the $5 reserve untouched by model traffic so it remains available for reconciliation or operator review.

Evidence: one endpoint, many model bills
A single OpenAI-compatible endpoint can present many billable models, so one wallet can accumulate charges from several model paths. Requesty advertises 600+ models through one OpenAI-compatible API, and freellmapi exposes 635 free model endpoints behind one /v1 endpoint. For Groq, freellm.net's provider snapshot lists 3 free models on an OpenAI-compatible base URL; verify the current model count at console.groq.com before relying on it. The point these citations support is that one endpoint can be a multi-model billing surface rather than a single-model budget — not any specific minimum model count.
| Source | Models or endpoints behind one interface | What it means for wallet control |
|---|---|---|
| Requesty | 600+ models via one OpenAI-compatible API | One route can select many billable models |
| freellmapi | 635 free model endpoints behind one /v1 endpoint | One base URL can fan out to many model bills |
| Groq | 6 free models online | Smallest cited breadth still exceeds a single-model assumption |
The breadth of the smallest cited endpoint matters because it sets the control scope. Any cap tied only to an alias must be evaluated against every billable model path the endpoint can serve — check the provider's current model list rather than assuming a fixed count. A request can move from one model to another behind the same interface while drawing on the same prepaid balance, so the cap has to account for that breadth before it can be called complete.
This is why the evidence supports aggregate awareness rather than alias-only confidence. An alias-only cap can govern the name a client sends, but it does not by itself govern every model that the same endpoint can serve. If one path is allowed to consume the remaining headroom, the wallet can still be overdrawn by another path that was never named in the alias rule.
Source discipline keeps the claim narrow. The Requesty, freellmapi, and Groq figures establish endpoint breadth and model availability; they do not establish prices, fees, rate limits, or wallet debit behavior. Use them to show that one endpoint can carry multiple model bills, and verify cost or balance behavior separately against the provider's own pricing and billing documentation.

Wallet, alias, or model cap: which wins?
The comparison has one winner: per-model subcaps inside the $45 committed total, enforced with the wallet aggregate check. Wallet-only and alias-only controls each stop one failure mode but leave the other open, so neither is sufficient by itself.
| Option | Blocks aggregate overdraw | Blocks one-model overrun | Winner |
|---|---|---|---|
| Wallet-only | Yes | No | No |
| Alias-only | No if aliases sum | Yes per alias | No |
| Per-model subcaps inside $45 | Yes with wallet check | Yes | Yes |
A wallet-only cap is aggregate-aware but model-blind. It can prevent the wallet from being overdrawn in total, yet it does not stop one model from consuming the shared committed balance before another model is routed. The result is a one-model overrun that the aggregate cap notices only after the spend has started.
An alias-only cap is the reverse. It protects each alias, but aliases can sum past the committed total. When several aliases each have remaining room, their combined requests can still overdraw the wallet while every alias remains under its own limit. The aggregate failure is invisible to alias-level enforcement.
The winning arrangement nests the subcaps under the wallet check. The wallet aggregate check establishes the shared boundary; the per-model subcaps then divide that boundary among models. That ordering blocks both aggregate overdraw and a single-model overrun, because no model can claim the whole committed amount and no alias group can exceed the wallet boundary. This is the only option in the comparison that answers yes to both blocking tests.
The myth that per-model caps alone stop overruns is killed by $45. If subcaps sum to $45 but the wallet aggregate check runs after alias selection, an extra alias can attempt spend until the wallet aggregate check rejects the request. The killing number is not a model price; it is the sum of the subcaps. The subcaps therefore do not replace the wallet gate; they operate inside it.
Operationally, keep all DeepSeek, GLM, and other subcaps summing to at most the committed total, and treat the wallet aggregate check as the outer gate for the nested cap. A new request should be denied at the configured committed threshold unless an approved logged override exists. The override must be logged because it is an exception to the nested cap, not a replacement for it.
The $50 cap math you must reconcile
The arithmetic is fixed before any routing decision: a $50 prepaid wallet minus a $5 reserve leaves $45 of committed spend. The 90% kill switch on that $45 committed cap is $40.50, so a new request is denied at $40.50 committed unless a logged override is approved. The config is invalid before the first request if the DeepSeek subcap, GLM subcap, and every other model subcap do not sum to at most $45. That is the reconciliation: $50 wallet, $5 reserve, $45 committed, $40.50 denial point.
Do not treat $50 as a flat model rate or assume provider prices from memory. Read the current DeepSeek and GLM per-1M-token input, output, and cache rates from their own price pages, then enter those values as variables in the ledger. The cited sources do not supply those DeepSeek or GLM rates, so the defensible method is verification at the source, not a guessed number.
The same discipline applies to any provider exposed through a shared OpenAI-compatible endpoint: Requesty states it routes 600+ models through one OpenAI-compatible API, and the freellmapi project describes 635 free model endpoints behind one /v1 endpoint, so one wallet can face many distinct price paths.Before every alias read, the ledger check must pull wallet_remaining, committed_spend, per_model_spend, and the wallet_re state together. Use wallet_remaining to confirm the prepaid balance still supports the $5 reserve, use committed_spend to test the $45 cap and the $40.50 denial point, and use per_model_spend to test the alias’s nested subcap. The check order matters because an extra alias can otherwise consume room that the wallet-level arithmetic assumed was still available.
The provider-price variables then convert expected tokens into expected committed spend before admission. For each request, estimate input tokens, output tokens, and any cache-read or cache-write tokens separately, multiply each by the verified per-1M-token rate from the provider price page, and add the result to committed_spend for the proposed call. If that projected total crosses $40.50 committed, deny the request unless the override is logged and approved. If it stays below the kill switch but the alias subcap would exceed its assigned share of the $45 committed pool, deny at the alias layer instead.
Keep the cap table auditable. Record the $50 wallet value, the $5 reserve, the derived $45 committed cap, the derived $40.50 kill switch, the verified DeepSeek and GLM input/output/cache variables with their source pages, and the timestamped ledger snapshot of wallet_remaining, committed_spend, and per_model_spend. A config whose subcaps add up above $45 should fail validation immediately; a request whose projected spend reaches the kill switch should fail admission immediately. That is how the arithmetic stays enforceable when many models share one billing surface.
What the available sources cannot prove
The cited sources leave three edge cases unresolved, and each one matters because the wallet rule has to survive conditions the model table does not describe.
OmniRoute’s documentation says Layer 3 model lockout can come from a per-model 429, a local 404, or mode denials, and that those lock just that model rather than the whole connection. It also separates terminal states—banned, expired, or credits exhausted—from cooldowns, describing them as operator-level conditions. That distinction matters here: a lockout is not a budget restoration event. If a DeepSeek alias is locked, the wallet should not infer that committed spend has been released or that the reserve has changed.Cursor’s published pricing note creates a second edge case. According to Cursor Docs, on Teams and Enterprise, a Balance or Intelligence route to a third-party model also incurs the Cursor Token Rate unless that model’s cache-read price is strictly below $0.10 per million tokens. A token-only subcap can miss that charge because the billable event is not just generated tokens; it is also cache reads at the stated threshold. The wallet-level check still has the decisive position: if committed spend has reached $40.50, the pre-request wallet denial stops the next request before a cache-read charge or another alias can push the wallet past the $45 committed cap.
The third gap is per-model granularity. The cited sources show many models exposed through shared OpenAI-compatible surfaces, but they do not prove that every gateway reports spend with enough model-level precision to enforce a distinct DeepSeek subcap, GLM subcap, and “other” subcap from billing data alone. Requesty describes 600+ models through one OpenAI-compatible API, freellmapi describes 635 free model endpoints behind one /v1 endpoint, and freellm.net's provider snapshot lists 3 Groq models on an OpenAI-compatible base URL. That is enough to show shared exposure, not enough to show clean per-model accounting.
These edge cases break different parts of a naive rule. OmniRoute terminal states break the idea that a model lockout behaves like a temporary cooldown with automatic budget recovery. Cursor’s $0.10 per 1M-token cache-read threshold breaks a subcap that counts only tokens. Missing per-model granularity breaks a cap that assumes the billing feed can identify each alias precisely. In each case, the rule still wins only because the wallet aggregate check runs first: reserve $5, cap committed spend at $45, and deny new requests at $40.50 committed unless a logged override is approved.
| Case | Rule breaks | Rule still wins |
|---|---|---|
| OmniRoute terminal state: banned, expired, or credits exhausted | Model lockout is operator-level, not a cooldown that restores budget. | Pre-request wallet denial stops new spend. |
| Cursor third-party cache-read threshold of $0.10 per 1M tokens | Token-only subcap misses cache charges. | Wallet check still stops at $40.50. |
| Per-model granularity not shown in grounding | Cap may accidentally be aggregate-only. | Distinct API key per model enforces. |
The practical check is therefore not “which model is being called?” first. It is whether the wallet aggregate can still authorize another request after the $5 reserve and $45 committed cap are applied. Then use distinct API keys per model where per-model granularity is not proven, and keep the wallet_re check in the pre-request path so terminal states, cache-read charges, and alias sprawl cannot turn a model-level event into wallet overdraw.
Worked $50 DeepSeek/GLM month
Here is the worked allocation and checkpoint worksheet for the month. We start with a $50 prepaid wallet. Before any routing happens, we hold $5 as an untouchable reserve and set the committed cap at $45. The kill switch sits at $40.50 committed. The subcaps are DeepSeek at $20, GLM at $20, and other models at $5. That sums exactly to $45, so the nested model limits fit inside the aggregate cap without leaving a gap for an extra alias to exploit.
Checkpoint A fires at $9.00 committed, leaving $41.00 in the wallet. At this point, read wallet_remaining before any alias is selected. The $41.00 remaining is above the $5 reserve, and committed spend of $9.00 is below both the $40.50 denial point and the $45 committed cap, so routing continues. The check is mechanical: committed_spend must stay under $40.50 (or $45 with an approved override), and wallet_remaining must stay above the $5 reserve, before the request is allowed to touch a per-model bucket.
Checkpoint B fires at $22.50 committed, leaving $27.50. Again, read wallet_remaining before alias resolution. The $27.50 remaining still clears the $5 reserve, and the subcap sum remains $45 on the books. DeepSeek and GLM have each been allocated $20, other $5, and the aggregate check still governs. If a new alias appears at this stage, it draws from the other bucket or is denied; it does not get a fresh line of credit against the wallet.
Checkpoint C fires at $40.50 committed, leaving $9.50. This is the kill switch. New requests are denied unless a logged override is approved. The $9.50 remaining is above the $5 reserve, but the committed total has reached the $40.50 threshold, so the gate closes. The subcap sum is still $45, but the aggregate checkpoint wins because it was evaluated first. An extra alias cannot overdraw the wallet here because there is no uncommitted aggregate room left to assign to it.
Frequently Asked Questions
If the wallet aggregate would be exceeded, what should happen before routing?
Deny the request before routing and record the denial reason.
Can a denied request silently fall through to another alias?
Do not fall through to another alias until the aggregate is rechecked.
How should an exception to the normal gate sequence be handled?
Any exception should be a logged override rather than a silent retry.
When should committed spend be reconciled against wallet_remaining?
Reconcile committed spend against wallet_remaining before the next request.
Why can a closed alias appear available even when it should not be used?
A stale balance can make a closed alias look available, while the aggregate check prevents that alias from reopening the wallet.
What should model traffic not consume?
Keep the $5 reserve untouched by model traffic so it remains available for reconciliation or operator review.
Quick answers
| In what order should the gates be run on every request? | The gates should be run in this order on every request: wallet aggregate, reserve, committed cap, then alias subcap. |
| What should happen if the aggregate spending limit would be exceeded? | If the aggregate would be exceeded, the request should be denied before routing and the denial reason recorded, without falling through to another alias until the aggregate is rechecked. |
| How should exceptions to the spending gates be handled? | Any exception should be a logged override rather than a silent retry. |
| Why should the reserve be kept untouched by model traffic? | The reserve should be kept untouched by model traffic so it remains available for reconciliation or operator review. |
| Why can a single OpenAI-compatible endpoint pose a risk to wallet control? | A single OpenAI-compatible endpoint can present many billable models, so one wallet can accumulate charges from several model paths, making it a multi-model billing surface rather than a single-model budget. |
Also worth reading: AI API costs: DeepSeek vs GLM via router — $0.001 per request vs $50 prepaid cap in 2026: AI API costs: DeepSeek vs · Limit AI API spend: $50 prepaid cap vs per-1M-token rates in 2026: Limit AI API spend: $50 · Keep AI costs under control: $0.00114/M per-route cap keeps GLM-4.5-Air under $50 in 2026: Keep AI costs under control: