Pricing
Jev AI Pricing — Credits, Official Rates, and What a Run Costs
Jev AI pricing has two parts on this page: prepaid Jev credits — one-time packs from $10, no subscription, never expiring — and the full official pricing math, so you always know exactly what a run costs.
Jev AI pricing bills input tokens only. Output tokens are free, and there is no monthly minimum — you pay for the state and questions you send, nothing else. Below: the official rates, what real volumes cost, how to estimate your own bill, and how direct pricing differs from third-party resellers.
Buy Jev credits
One-time packs that cover your playground runs and API calls. No subscription, ever.
Starter
$10 one-time
100,000 credits
Validate a real workflow — from playground experiments to your first API calls in production.
- 100,000 credits — never expire
- Choice, Score & Noul questions
- Probabilities + confidence in every answer
- 3 concurrent requests
- Access to the online playground
- Email support
Pro
$25 one-time
250,000 credits
For small teams running Jev in production — routing, scoring and filtering every day.
- 250,000 credits — never expire
- All three question types
- 10 concurrent requests
- API key management
- Usage history
- Priority email support
Scale
$100 one-time
1,000,000 credits
High concurrency and multi-project setups — batch jobs, event streams, heavy product loops.
- 1,000,000 credits — never expire
- 50 concurrent requests
- Multi-project API keys
- Usage history + export
- Priority routing
- Priority email support
One-time purchase. Credits never expire. No subscription, no auto-renew.
Credits are not on sale yet — joining the waitlist saves your spot, and we will email you the moment they go live.
Credit conversion — credits to tokens
Credits are only useful if you can see through them to the real unit — input tokens. Our conversion will be published here, in full, before a single pack goes on sale:
| Credits | Input tokens | Value at the official rate |
|---|---|---|
| 1,000 | TBD | TBD |
| 100,000 | TBD | TBD |
| 1,000,000 | TBD | TBD |
TBD until launch: we will not quote a conversion we have not locked in with the upstream provider. That same rule is how you should judge any credit seller — ask how many input tokens one credit buys before you pay, and compare it against the official rate of $0.042 per million input tokens below.
Jev AI Pricing — Official TypeSafe Rates
| Input tokens | $42 per billion — $0.042 per million |
|---|---|
| Output tokens | Free |
| Rate limits | 100K tokens/sec · 80 requests/sec |
| Context window | 64K tokens per request (state + longest question ≤ 32K) |
What a run actually costs
Same math at three volumes, for three input sizes:
| Input per request | 10,000 requests | 100,000 requests | 1,000,000 requests |
|---|---|---|---|
| ~400 tokens (official ticket-example size) | $0.17 | $1.68 | $16.80 |
| 1,000 tokens | $0.42 | $4.20 | $42.00 |
| 5,000 tokens | $2.10 | $21.00 | $210.00 |
How it is computed: cost = input tokens × $0.042 ÷ 1,000,000. Output is not billed, so it does not appear in the formula.
What kind of product lands at each volume
10,000 requests a month is the scale of a small internal tool — a helper that routes a few hundred support tickets a week, or tags feedback for one team. Even at a fat 5,000 tokens per request, that is $2.10 a month. At the ~400-token size of the official example, it is seventeen cents. This is the “just try it in production” tier: the cost rounds to zero against a developer’s time.
100,000 requests a month is a real product loop in a mid-size SaaS — every inbound message triaged, every user report scored, one decision per active user per day at three thousand daily actives. At 1,000 tokens per request you are paying $4.20 a month; at 5,000 tokens, $21. For comparison, that is often less than what the same volume costs on a chat model for a single day.
1,000,000 requests a month is high-frequency batch territory — replaying a year of history through a classifier, scoring every event in a stream, or running decisions inside a loop that fires thousands of times an hour. This is where the input-only billing really shows: a million ~400-token runs is $16.80, and a million 5,000-token runs is $210 — a bill you can compute before you run the job, not after.
The deeper point of free output: your cost is fully predictable from your own input. The bill depends only on what you send — not on how long or how rich the model’s answers are. A run that returns a full distribution over eight options costs the same as one that returns a bare yes/no. For budgeting, that means you can price a feature before writing a line of code.
How to Estimate Your Jev AI Bill
One formula, three numbers you already know:
monthly cost = avg input tokens per request × requests per day × 30 × $0.042 ÷ 1,000,000
Worked example, a support-triage feature: your average ticket plus question comes to ~350 tokens, and you route 2,000 tickets a day. That is 350 × 2,000 × 30 = 21 million input tokens a month → 21 × $0.042 = $0.88 a month.
A heavier one, a review-scoring loop in production: ~1,500 tokens of context per review, 40,000 reviews a day. That is 1.8 billion tokens a month → 1,800 × $0.042 = $75.60 a month — at a volume that would be eye-watering on a per-output-token chat model. If your numbers sit between these examples, interpolate; the table above covers the same math at fixed round volumes.
How that compares to chat models
Mainstream LLM input prices run roughly $0.20–$10 per million tokens (TypeSafe’s own comparison range). On the same input-price basis: a $0.20 model is about 4.8× Jev’s input price, and a $10 model is about 238×. Note this compares input price only — not the total cost of a feature, where token counts differ by task. But for judgment-shaped work, the gap is large enough that cost stops being a design constraint: you can put a decision in the hot path instead of batching it.
Official direct rates vs. third-party resellers
Everything on this page is TypeSafe’s direct rate. Around any new model, a resale layer appears fast — aggregator listings, credit-pack storefronts, wrapper sites — and their pricing basis is not always what you assume. At least one widely-read summary currently lists Jev at close to an order of magnitude above the official rate, and some storefronts sell “credits” without publishing how a credit maps to tokens. Check the basis before you buy:
| Channel | Type | Billing basis |
|---|---|---|
| TypeSafe (direct) | Official | Per input token — the rates on this page, output free |
| OpenRouter | Model marketplace | Per-token rates set on their platform |
| LiteLLM | Open-source gateway | Passthrough — calls billed by your own provider account |
| Requesty · Pydantic · aiMLAPI | SDK / aggregator | Varies by platform — verify before you buy |
| Third-party reseller sites | Resellers | Often credit packs; token conversion frequently unpublished |
The practical rule: price per input token, or credits with a published conversion — if a seller quotes neither, you are buying an unknown quantity. Known distribution channels for Jev include OpenRouter, LiteLLM, Requesty, Pydantic, and aiMLAPI (listed for reference, not endorsed, and not price-checked here).
Jev AI Pricing FAQ
Do credits expire?
No. Every pack is a one-time purchase and credits never expire — no subscription, no auto-renewal, no monthly charge. Buy once, use them at your own pace.
Is there a subscription?
No. Credits are strictly one-time purchases with no recurring charge. And Jev’s own official pricing is usage-based too — per input token, output free, no monthly fee, no minimum spend. If you stop sending requests, nothing bills.
How is buying credits here different from buying direct from TypeSafe?
Direct from TypeSafe you pay per input token on your own API key — pure usage billing after the fact. Credits here are prepaid packs: one fixed payment, spend tracked in credits, never expiring. Before anything goes on sale we will publish the exact credit-to-token conversion on this page, so you can check it against the official $0.042 rate yourself.
How is Jev billed?
Input tokens only: $0.042 per million ($42 per billion). Output tokens are free. It is pure usage-based pricing — there is no monthly fee, no minimum, and no tier to buy into. You pay for the state and questions you send, nothing else.
Is output really free?
Yes. Output tokens are not billed — you pay for the state and questions you send, not for what comes back. That is why every cost figure on this page counts input only. It also means longer or richer answers never increase your bill: the size of the decision you get back is not a cost driver.
How many tokens is a typical request?
The official support-ticket example is on the order of ~400 input tokens — a customer message plus some account context and a question. A heavier state, like a long document plus several questions, runs into the thousands. As a rough estimate, count about a quarter of the characters you send as tokens.
How do I estimate my bill?
Multiply it out: average input tokens per request × requests per day × 30 days × $0.042 ÷ 1,000,000. Two worked examples are in the section above — a light workflow lands under a dollar a month, and a heavy product loop in the tens of dollars. The volume table gives you the same math pre-computed at three scales.
What happens if I exceed rate limits?
Limits are 100K tokens per second and 80 requests per second. Beyond them the API returns HTTP 429 with a retry-after header — your code backs off and retries, ideally with jittered exponential backoff. Rate limiting does not cost anything extra; it is a throttle, not a fine.
Is the price the same on OpenRouter or other platforms?
Not necessarily. Third-party platforms and resellers set their own rates, and some repackage usage as credits without publishing the token conversion. The $0.042 figure on this page is TypeSafe’s direct rate. Wherever you buy, check the billing basis first — per input token, or credits with an unpublished conversion.
Why is Jev so much cheaper than chat models?
Because the job is smaller and the output is tiny. A chat model composes text token by token; Jev returns short typed objects — a choice with probabilities, a score, a probability value — and is optimized for that narrower task. The honest caveat: $0.042 vs $0.20–$10 compares input price per token, not the total cost of a feature.
Be first when Jev credits go live
Credits are not on sale yet. Leave your email and we will notify you the moment packs are available — along with the full published credit-to-token conversion. No spam, and nothing else will ever use this list.
One-time packs · Credits never expire · No subscription, no auto-renew
Rates on this page are TypeSafe’s official published numbers. JevAI Online is an independent resource — not affiliated with or endorsed by TypeSafe AI.