Billing
MindsHub Inference is pay-as-you-go, with no subscription. Two things fund your requests:
Included tokens. The default monthly allowance is 5,000,000 tokens, usable on mindshub_air; per-organization overrides exist, so check included_tokens.limit (below) for yours. The tokens reset monthly on the anniversary of your organization's creation (not the 1st); unused tokens don't roll over. Programmatically, the covered model is the one with "free_bucket": true in the entitlements endpoint.
The wallet. A prepaid, organization-level credit balance that funds everything else: every other model, embeddings, and web-search charges. Credits never expire.
A request is admitted when your wallet has available balance, or when it's on mindshub_air with included tokens left; otherwise it's refused up front with 402 wallet_empty or 429 included_allowance_exhausted (see Errors: you get the 429 only if your organization has never added a payment method; with a card on file, running out is always the 402). A refused request consumes nothing. Admission checks the balance but does not reserve the request's full estimated cost, so a large request against a nearly-empty wallet can briefly overdraw it.
How the wallet works
- Top up from the console. Minimum top-up is $10.
- Auto-recharge (optional): set a threshold and a target: when the balance crosses the threshold, your card is charged back up to the target, typically within a few minutes. A monthly recharge cap (default $100) limits automatic charges; hitting it pauses recharging until the calendar month rolls over.
- Your card is only charged for top-ups and recharges. Usage consumes prepaid credits.
- A declined auto-recharge stops recharging until the billing owner fixes the payment method; it never retries a declined card on its own. Requests keep working until the balance runs out.
- Wallet visibility is role-based: the billing owner sees balances and dollar figures; other members see their own usage in tokens only.
- An empty wallet never revokes API keys (Authentication); requests resume automatically once credit lands.
What gets metered
Four token counters, per request:
| Counter | What it is | Billed at |
|---|---|---|
| Input tokens | Prompt tokens not served from cache | The model's input rate |
| Output tokens | Everything the model generates, including internal reasoning | The model's output rate |
| Cached input tokens | Prompt tokens read from the provider's prompt cache | The model's cached-input rate, roughly a tenth of input on most of the catalog but not uniformly so. Read it off the price list rather than deriving it |
| Cache-write tokens | Prompt tokens written into the cache | The model's cache-write rate: the input rate on most models, 1.25× input on the Claude family, mindshub_air, and the GPT 5.6 line. Not billed at all on the Gemini models, which show n/a in the price list |
Prompt caching is automatic and you never have to ask for it. On most of the catalog MindsHub marks the provider's cache breakpoints on the stable prefix of your request; on the rest the provider caches implicitly and there is nothing for us to mark. A request that already carries its own cache_control breakpoints, as Claude Code sends on Messages, is passed through exactly as you sent it. You see the effect as cached_tokens in responses and a lower effective input price. One rough edge: on Claude targets a system prompt sent as an array of content parts rather than a plain string gets no breakpoint of its own. The rolling breakpoint on the previous message picks it up from the second turn onward, so the cost is one extra full-price turn rather than every turn.
How this interacts with the included tokens:
- Cached reads draw included tokens at full weight, 1:1: the cache discount applies to the price, not the token count.
- Cache writes never draw included tokens; they bill to the wallet where priced.
- Web searches, page fetches, and embeddings always bill to the wallet, even when the tokens of the same request were covered by included tokens.
The full matrix is the summary table at the bottom.
Price list
These are MindsHub's prices; they track the upstream providers' list prices. Per million tokens, as of August 2026 (the console is the authoritative, current source):
| Model | Input | Output | Cached input | Cache write |
|---|---|---|---|---|
mindshub_air | $0.20 | $1.20 | $0.02 | $0.25 |
haiku | $1.00 | $5.00 | $0.10 | $1.25 |
sonnet | $2.00 | $10.00 | $0.20 | $2.50 |
opus | $5.00 | $25.00 | $0.50 | $6.25 |
fable | $10.00 | $50.00 | $1.00 | $12.50 |
gpt | $5.00 | $30.00 | $0.50 | $6.25 |
gpt-terra | $2.00 | $12.00 | $0.20 | $2.50 |
gpt-luna | $0.20 | $1.20 | $0.02 | $0.25 |
gpt-codex | $1.75 | $14.00 | $0.18 | $1.75 |
gpt-mini | $0.75 | $4.50 | $0.08 | $0.75 |
gpt-nano | $0.20 | $1.25 | $0.02 | $0.20 |
gemini | $2.00 | $12.00 | $0.20 | n/a |
gemini-flash | $0.75 | $3.75 | $0.08 | n/a |
gemini-flash-3-6 | $0.75 | $3.75 | $0.08 | n/a |
kimi | $3.00 | $15.00 | $0.30 | $3.00 |
deepseek | $1.32 | $3.96 | $0.05 | $1.32 |
deepseek-v4-pro | $1.74 | $3.48 | $0.15 | $1.74 |
qwen | $2.00 | $6.00 | $0.25 | $2.00 |
qwen-3-7-plus | $0.40 | $1.60 | $0.08 | $0.40 |
glm | $1.40 | $4.40 | $0.14 | $1.40 |
muse-spark | $1.25 | $4.25 | $0.15 | $1.25 |
muse-spark-1-1 | $1.25 | $4.25 | $0.15 | $1.25 |
grok | $2.00 | $6.00 | $0.50 | $2.00 |
grok-4-5 | $2.00 | $6.00 | $0.30 | $2.00 |
embed-small | $0.02 | n/a | n/a | n/a |
Aliases are described in Models.
deepseek-v4-pro keeps its established alias rates after its unavailable
provider ID was redirected to the served deepseek-v4-pro-0813 release.
Long-context pricing
Some providers charge more for large prompts, and MindsHub passes those thresholds through. When the total prompt (uncached, cached, and cache-write tokens combined) exceeds the model's threshold, the higher rates apply to the entire request, on every dimension:
| Model | Threshold (prompt tokens) | Input / Output | Cached input | Cache write |
|---|---|---|---|---|
mindshub_air | above 272,000 | $0.40 / $1.80 | $0.04 | $0.50 |
gpt | above 272,000 | $10.00 / $45.00 | $1.00 | $12.50 |
gpt-terra | above 272,000 | $4.00 / $18.00 | $0.40 | $5.00 |
gpt-luna | above 272,000 | $0.40 / $1.80 | $0.04 | $0.50 |
gemini | above 200,000 | $4.00 / $18.00 | $0.40 | n/a |
grok | at or above 200,000 | $4.00 / $12.00 | $1.00 | $4.00 |
grok-4-5 | at or above 200,000 | $4.00 / $12.00 | $0.60 | $4.00 |
Note the cached rates double too: a long, heavily-cached conversation is exactly the workload that crosses these thresholds. All other models price flat across their full context window.
Web search and fetch
Per 1,000 uses, on models where web tools are available. mindshub_air is not one of them: web tools are dropped there, so no search or fetch charge can arise on that alias no matter what your tools array says.
| Models | Search | Fetch |
|---|---|---|
| Claude and GPT families | $10.00 | n/a |
kimi, deepseek, deepseek-v4-pro, qwen, qwen-3-7-plus, glm, muse-spark, muse-spark-1-1 | $7.00 | $1.00 |
gemini, gemini-flash, gemini-flash-3-6 | $14.00 | n/a |
grok, grok-4-5 | $5.00 | n/a |
Where no fetch price is listed, fetched pages bill as ordinary input tokens rather than per fetch.
Checking usage and balance from code
Two account endpoints accept your API key. They live on auth.mindshub.ai (not api.mindshub.ai), and the trailing slash is part of the path.
GET https://auth.mindshub.ai/v1/entitlements/me/: what you can use right now:
{
"wallet": {"balance_usd": "90.45", "can_consume": true, "auto_recharge": {"enabled": true, "...": "..."}},
"is_billing_owner": true,
"models": [
{"id": "mindshub_air", "label": "MindsHub Air", "free_bucket": true, "embedding": false,
"enabled": true, "reasoning_efforts": null, "default_reasoning_effort": null}
],
"included_tokens": {"limit": 5000000, "used": 58, "remaining": 4999942},
"next_refresh_at": "2026-08-25T13:20:26Z"
}
wallet is null unless the key belongs to the billing owner. next_refresh_at is when the included tokens refill. free_bucket marks the model the included tokens cover.
GET https://auth.mindshub.ai/v1/usage/summary/?range=period&group_by=model: what you've consumed. Response (excerpt; some fields omitted for brevity):
{
"range": {"requested": "period", "start": "2026-07-01T00:00:00Z", "end": "2026-08-01T00:00:00Z"},
"results": [
{"dimensions": {"model_alias": "opus"},
"usage": {"input_tokens": 218809, "output_tokens": 226135,
"billable_input_tokens": 218809, "billable_output_tokens": 226135,
"search_count": 87, "fetch_count": 16},
"cost_usd": "19.54"}
],
"next_cursor": "eyJvIjogM30=",
"totals": {"usage": {"...": "..."}, "cost_usd": "19.54"},
"included_tokens": {"limit": 5000000, "used": 58, "remaining": 4999942,
"window_start": "2026-07-25T13:20:26Z", "window_end": "2026-08-25T13:20:26Z"}
}
Reading it correctly:
- Two different windows in one response.
range=periodmeans the current billing period; treat the returnedrange.start/range.endas authoritative rather than assuming calendar months. Theincluded_tokensblock uses a different window: your organization's anniversary-based allowance cycle. The two will rarely line up. cost_usdis a decimal string, populated only for the billing owner (nullotherwise), rounded to cents, so small usage reads"0.00". Mid-period figures come from the in-progress invoice and can still move. There is no per-request cost anywhere in the API.- Results are paginated: pass
limit(default 50, max 200) and follownext_cursor. - Rows break out cached-input, cache-write, and long-context tokens alongside input, output, search, and fetch, each with a billable twin.
Summary of what bills where
| Spend | Draws included tokens? | Bills wallet? |
|---|---|---|
Tokens on mindshub_air (tokens remaining) | yes | no |
Tokens on mindshub_air (tokens exhausted) | no | yes |
| Tokens on any other model | no | yes |
| Cache writes | never | yes (where priced) |
| Web search / fetch | never | yes |
| Embeddings | never | yes |
count_tokens, GET /v1/models, refused requests | no | no |