TypeSafe's price for Jev fits in one line: $0.042 per million input tokens, and output is free. That's accurate, but it doesn't tell you what you'll actually pay, because nobody thinks in tokens. You think in tickets, enquiries or decisions.
So we worked it out from real usage. Across 8,654 messages in our support routing and spam tests, Jev cost us between $0.015 and $0.27 per 1,000 decisions. The whole test run came to about a dollar.
Here's what drives that number, what it looks like at your volume, and the costs that aren't on the price list.
How Jev Pricing Works#
You pay for input tokens only. A token is roughly three-quarters of an English word, and every request's input includes three things:
- The state - the text you want a decision about (the ticket, the enquiry, the document).
- The question - your instructions ("Which support topic does this message belong to?").
- The criteria - your options and their descriptions ("billing", "technical", "sales", plus any explanation or examples you add).
Jev does report output tokens - about 828 per call in our tests - but at the time of writing you're not billed for them. That's the big difference from a language model, where you pay for every word it writes back.
One caution: this is early-access pricing. TypeSafe can change it, so build your business case with some headroom.
What It Cost in Our Tests#
| Task | Input tokens per call | Cost per 1,000 decisions |
|---|---|---|
| Spam check (one yes/no question) | ~360 | $0.015 |
| Support routing, 77 topics, names only | ~1,706 | $0.072 |
| Support routing, 77 topics, names + 3 examples each | ~6,355 | $0.267 |
The lesson from the table: the question costs more than the message. A support message is a sentence or two. The list of 77 topics with three example messages each was most of the 6,355 tokens - and it goes along with every single call.
That's not wasted money. Those examples lifted routing accuracy from 80.8% to 88.8%. But it means your criteria, not your data, usually decide the bill.
What It Looks Like per Month#
Monthly Jev cost, using the token counts above:
| Decisions per month | Spam check | Routing (names only) | Routing (with examples) |
|---|---|---|---|
| 10,000 | $0.15 | $0.72 | $2.67 |
| 100,000 | $1.51 | $7.17 | $26.69 |
| 1,000,000 | $15.12 | $71.65 | $266.91 |
These are straight calculations from our measured token counts, not quotes. Your numbers will differ with longer messages or more detailed criteria - which is why we'd always measure a sample of your real traffic first.
Jev vs a Language Model: The Honest Comparison#
Here's the same workload priced at OpenAI's list prices (September 2026), input tokens only:
| 1,000,000 decisions a month | Jev | gpt-5-nano ($0.05/M) | gpt-6-luna ($0.10/M) | gpt-6-sol ($2/M) | gpt-6-astra ($10/M) |
|---|---|---|---|---|---|
| Spam check (~360 tokens) | $15 | $18 | $36 | $720 | $3,600 |
| Routing with examples (~6,355 tokens) | $267 | $318 | $636 | $12,710 | $63,550 |
A language model would also charge for its output. For a one-word label that's small - unless it's a reasoning model that "thinks" first, because those thinking tokens are billed as output too.
Three honest caveats:
- Against the cheapest models, there's barely a gap. gpt-5-nano costs about the same as Jev per decision here.
- Prompt caching can flip it. OpenAI charges 90% less for repeated prompt text it has cached - like a long list of topics sent with every request. If most of that routing prompt is cached, a cheap model's bill drops well below Jev's $267. Short requests like the spam check are too small to benefit.
- Against mid-range and flagship models, the saving is dramatic. If you're using a big model to make simple decisions at scale, this is where the headline "hundreds of times cheaper" numbers come from.
So Jev isn't automatically the cheapest option. Its real advantages are typed answers, a confidence score with every decision, and speed - with price as a bonus if you're currently paying for a bigger model.
We haven't benchmarked a language model's accuracy on the same data in these tests, so this table is about cost only. Cheaper is only better if the answers are good enough - which is a separate test.
The Costs Nobody Mentions#
The token price is the smallest cost in most switches. Budget for these as well:
1. The engineering work. Someone has to find the decision calls in your product, rewrite them as Jev questions and ship the change. For a handful of calls that's days, not months - but it's rarely free.
2. Labelling examples. To trust Jev's confidence score, you need to set a threshold on your own labelled data. Our confidence threshold test found 200-500 labelled examples is the practical minimum. That's an afternoon or two of someone's time.
3. A fallback. TypeSafe's current terms give no uptime guarantee, so you'll want a backup model or rule for outages and low-confidence answers. The backup costs money when it runs - see our UK safety guide.
4. Human review. A sensible setup sends uncertain answers to a person. In our routing test, a 0.9 confidence threshold sent about one in five messages to the fallback. Whoever handles those is part of the cost.
5. Compliance paperwork. If you send personal data, a UK business will need the data processing agreement and a transfer risk assessment, because Jev is hosted in the US.
When Jev's Pricing Actually Matters#
Run the numbers before you switch. As a rough guide:
- Low volume, cheap model: a few thousand decisions a month on a budget model costs a few dollars. The switch won't pay for itself - see when not to use Jev.
- Expensive model at volume: hundreds of thousands of decisions a month on a mid-range or flagship model is where the savings become a real line item. If you're already on the cheapest models, cost alone won't justify the switch.
- Speed-sensitive: sometimes the reason to switch isn't cost at all. Jev answered in about a quarter of a second in our tests, which matters for things like voice agents deciding where to route a call.
How to Estimate Your Own Bill#
- Pick one decision your product makes with an AI call today.
- Count its input tokens - your current provider's logs usually show this. If you'd add criteria or examples for Jev, add those too.
- Multiply: tokens per call × calls per month ÷ 1,000,000 × $0.042.
- Compare with what that call costs you now, including output tokens.
- Subtract the hidden costs above, and see if what's left is worth it.
Frequently Asked Questions#
How much does Jev cost?#
TypeSafe charges $0.042 per million input tokens during early access, and output tokens are free. In our tests that worked out at $0.015 to $0.27 per 1,000 decisions, depending on how long the question and options were.
Does Jev charge for output tokens?#
Not at the time of writing. Jev reported around 828 output tokens per call in our tests, but only input tokens are billed.
Is Jev cheaper than GPT or Claude?#
It depends on which model. Against mid-range and flagship models like gpt-6-sol or gpt-6-astra, Jev is dramatically cheaper per decision. Against the cheapest models like gpt-5-nano, the prices are similar, and prompt caching can make the cheap model cheaper. Whether switching pays off also depends on your volume, the engineering cost, and whether Jev's accuracy is good enough for the task.
What makes a Jev request expensive?#
Mostly the criteria. Long option lists and example messages are sent with every call. In our routing test, adding three examples per topic multiplied the input from about 1,706 to 6,355 tokens - and raised accuracy by eight points.
Will Jev's pricing change?#
It may. The current price is TypeSafe's early-access pricing, so leave headroom in your business case.
Want to know what Jev would cost - and save - on your actual traffic? Our Jev Switch Check measures your real AI calls, tests them against Jev and a backup model, and gives you the saving in pounds. Start with a free savings estimate.
AI engineer at BrightBit Digital
