Jev Pricing Explained: $0.042/M Tokens and the Real Cost Math (Oct 2026)

The price, up front: Jev costs $0.042 per million input tokens ($42 per billion). Output tokens are free. There is no per-call fee, and TypeSafe publishes no tier list — no Pro, no Team, no Enterprise SKU. Enterprise buyers get custom agreements plus zero data retention. That’s the entire pricing page, and it fits on one line of TypeSafe’s official models docs.

The rest of this page is the part the pricing page doesn’t tell you: what that number actually buys, where the limits are, how it compares to the alternatives, whether the price will survive, and — the reason this is on AIExtraCash — how the spread between Jev and everything else is itself a business.

What the $0.042 covers (and what it doesn’t)

Jev is a System One model: it returns typed decisions (classifications, scores, yes/no judgments), not prose. That’s why output is “too cheap to meter” — the outputs are tiny by design.

• Charged: input tokens only. That includes your state (reference material, records) plus every question you send, evaluated in parallel.
• Free: all output tokens.
• Not charged: no per-request fee, no seat fee, no platform fee.
• Not included: anything non-text. Jev takes text only — images, audio, video, and binaries must be pre-processed into text before they hit the API. That preprocessing is your cost, not TypeSafe’s.
• Context budget: 64k tokens per request (32k for state plus the longest question). Pack many questions into one request via speculative fan-out to amortize the state cost.

The practical takeaway: Jev’s pricing rewards batching. One big request with 500 questions against the same state costs roughly the same input as 500 small requests — but far fewer requests against your rate limit.

Rate limits: recently tightened

Current docs (authoritative as of October 2026):

Limit	Value
Tokens per second	100K per account
Requests per second	40 per account
On exceed	429 Too Many Requests

The official SDKs retry with exponential backoff and honor the retry-after header automatically. If you call the HTTP API directly, build your own backoff.

One flag: these limits moved down since launch. Early launch coverage reported 250K tokens/sec and 1,200 requests/min. The docs now say 100K/sec and 40 req/sec (2,400/min — so the request cap actually rose while the token cap fell). Either way, don’t architect around launch-day blog numbers; the docs page is the source of truth, and it can change again.

The $5 free credit

New accounts get $5 in free credit — about 120 million input tokens at the current rate, by TypeSafe’s own math. It landed when the waitlist was removed around September 20–21, 2026.

120M tokens is a serious evaluation budget: enough to run tens of thousands of real classification decisions before spending a dollar. We broke down exactly how far it stretches in Jev free credit: how far $5 really goes.

The real cost math: Jev vs the alternatives

Raw per-token pricing tells only half the story, because Jev and chat models do different-shaped work. Here are both — per-token rates (official list prices) and per-decision costs on classification-shaped tasks (with attribution, because vendor benchmarks and independent tests disagree on the exact multiple):

Model	Input price	Output price	Cost per decision-case	Source
Jev	$0.042/M	Free	~$0.0004	TypeSafe docs + vendor eval
GPT-5.6 Terra	$2.00/M	$12.00/M	~$0.0304	OpenAI pricing + TypeSafe 4-workflow eval (vendor)
GPT-5.6 Sol	$2.00/M	$10.00/M	~$0.0836	TypeSafe 4-workflow eval (vendor)
Claude Fable 5.1	higher	higher	~$0.10–0.23 est.	Every (independent, ~580x) / The Register (~238x)

Cost per 1,000 classification decisions. Vendor eval figures for Jev/Terra; Claude Fable derived from independent tests (Every, The Register). Decision-shaped tasks only — not chat.

Reading the table honestly:

• On input tokens alone, Jev is roughly 1/48th the price of GPT-5.6 Terra ($2.00 ÷ $0.042). And Terra still charges $12/M for output; Jev charges nothing.
• TypeSafe’s vendor claim (their 4-workflow eval): 193.6x faster and 444.6x cheaper than the average of GPT-6 Astra and Fable 5.1. Vendor claim — treat accordingly.
• Independent numbers land in the same neighborhood but vary: Every’s test found ~25x faster and ~580x cheaper than Claude Fable 5.1 on a single extraction task; The Register reported 238x cheaper than Claude Fable 5.1.
• TypeSafe’s own general range: 20–200x faster, 40–400x cheaper. The honest summary: “tens to hundreds of times cheaper on decision-shaped work,” with the exact multiple depending on the task.

The key insight for buyers: the multiple is biggest exactly where the work looks like decisions, not conversation — classification, extraction, routing, scoring. The more prose in the output, the less Jev’s pricing advantage matters (and the less Jev is the right tool at all).

For the full landscape of what else competes here, see Jev alternatives.

Will the price last?

Probably not at exactly $0.042 — and TypeSafe basically says so itself. Two things the company has admitted, paraphrased:

1. It can’t prove the pricing isn’t subsidized — at $0.042/M with free output, the margin math only works at enormous scale or with subsidy.
2. Seed-stage pricing rarely survives. The history of developer APIs is a history of launch prices that crept up once usage did.

None of that makes Jev a bad bet today. It makes it a timing bet: the spread between Jev and GPT-5.6-class models is widest right now, and the money play below is about capturing the spread while it exists. Build so you can re-price or swap models later; don’t sign a five-year client contract that assumes $0.042 forever.

The money angle: sell the spread

This is the core Jev money play, and it’s an arbitrage:

Swap an expensive LLM classifier for Jev inside a client’s workflow, and keep the difference.

The worked example:

• A client runs 1M classification decisions/month (support ticket routing, content moderation, lead scoring — pick one).
• On a GPT-5.6 Terra-class model, that’s roughly $30,000+/month in API costs (input at $2/M plus output at $12/M adds up fast at volume).
• On Jev, the same workload costs roughly $400/month.
• You rebuild their classifier on Jev, charge the client $5,000/month as a managed service, and pocket ~$4,600/month in spread — while the client still saves 80%+ versus their old bill.

That’s the “sell the system” model: the client doesn’t buy tokens, they buy a working classifier that used to cost them $30k. Your margin is the gap between Jev’s price and everyone else’s. Every month the $0.042 price holds, the gap — and your margin — persists.

Three notes for making it real:

1. Start with the $5 credit. 120M tokens is enough to rebuild and benchmark a real client workflow before spending anything — that’s your free proof-of-concept. (How far $5 goes)
2. Sell decisions, not tokens. Quote per-decision or per-month, never per-token. Your price should track the value (replacing a $30k bill), not your cost ($400).
3. Watch the rate limits. 100K tok/s and 40 req/s is generous for one client, but if you’re running ten clients through one account, batch aggressively and backoff correctly.

The full playbook — which workflows to target first, how to pitch the swap, and the onboarding script — is in Make money with Jev. For where Jev sits in the broader market, start at the Jev Hub, and check the Jev waitlist status if you haven’t gotten access yet.

Scam warning

Jev’s launch pricing attracted impersonators: fake “Jev” reseller and console sites have been spotted charging 6–11.5x the official rate for the same API. There is exactly one real front door: console.typesafe.ai for sign-up, docs.typesafe.ai for docs. If a site quotes you anything other than $0.042/M input with free output, walk away.

References

• TypeSafe docs: Models — official price ($42/Btok, $0.042/Mtok), output tokens free, rate limits (100K tok/s, 40 req/s), enterprise ZDR
• AYAutomate: Jev / TypeSafe System One model — pricing in context; The Register 238x and Every ~580x independent figures
• ExplainX: Jev general availability, no waitlist — $5 credit figure, waitlist removal timing