How much does Jev cost?

Jev costs $0.042 per million input tokens, and output tokens are free (checked in September 2026). TypeSafe’s homepage writes the same price as $42 per billion input tokens.

A small call, one short message plus a question, reports around 300 input tokens in TypeSafe’s docs. That’s about $0.0000126 per call, so one dollar pays for roughly 80,000 of them.

Jev is TypeSafe AI’s decision model. It doesn’t generate text: you send it some data and a list of questions, and it returns typed answers with probabilities (a yes/no probability, one option from a list you defined, or a position on a scale). If you’re new to it, start with my deep dive into Jev. Here we only look at what it costs and how to predict your bill.

The quick answer

The price is the same for jev-1.13.0, the current model, and for the jev-latest and jev-preview aliases, which both point to it.

How does Jev billing work?

TypeSafe charges per input token, and input is everything you send. That’s the state (the ticket, email, or document you want a decision about) plus every question with its instructions and criteria. A Choice with 40 long option descriptions costs more than a yes/no question, because those descriptions are input too.

Every response reports what you used. This is the response from TypeSafe’s quickstart, which asks three questions about a 131-character support message (I trimmed two of the answers):

{
  "model": "jev-1.13.0",
  "answers": {
    "is_urgent": { "type": "noul", "noul": 1.0 }
  },
  "usage": {
    "input_tokens": 392,
    "output_tokens": 65
  }
}

Notice that output_tokens is not zero. Jev counts output tokens, it just doesn’t charge for them, so this call costs 392 input tokens, or $0.0000165.

392 is a lot of tokens for such a short message. The API reference has an example with a 46-character state and one short question, and it reports 296 input tokens. The docs don’t explain the gap, but it behaves like a fixed cost of a few hundred tokens on every request. For tiny inputs, that fixed part is most of what you pay.

How do I estimate the cost of one call?

Start with the fixed part, about 300 tokens. Then add the state and the questions.

For the state, the usual rule of thumb for English text is 4 characters per token. TypeSafe doesn’t publish a ratio, but its own numbers back it up. In the Parallel questions cookbook, 13 single-question calls over a 53,777-character Wikipedia article cost $0.006090 in total. At $0.042 per million, that’s 145,000 tokens, about 11,150 per call, or close to 5 characters per token. Dividing by 4 errs on the high side.

A short question adds a few dozen tokens in the docs’ examples, and questions with long criteria add more. So a safe estimate is:

input tokens ≈ 300 + (characters in state ÷ 4) + (50 × number of questions)

Against the docs’ two small examples this comes out about 20% high, which is the direction you want when you’re budgeting. Once you have access, send ten real inputs with your real questions and read usage.input_tokens. That beats any formula.

How much would a real workload cost?

Let’s turn the estimate into a function we can run before writing any integration code. It takes the number of items, the average length of one item, and how many questions we ask about each:

const PRICE_PER_MILLION = 0.042

function estimateCost({ items, charsPerItem, questions }) {
  const tokensPerCall = 300 + charsPerItem / 4 + questions * 50
  const totalTokens = items * tokensPerCall
  const dollars = (totalTokens / 1_000_000) * PRICE_PER_MILLION
  return { tokensPerCall, totalTokens, cost: `$${dollars.toFixed(2)}` }
}

console.log(estimateCost({ items: 100_000, charsPerItem: 800, questions: 5 }))
console.log(estimateCost({ items: 1_000_000, charsPerItem: 400, questions: 3 }))
console.log(estimateCost({ items: 5_000, charsPerItem: 40_000, questions: 10 }))

Running it with Node.js prints:

{ tokensPerCall: 750, totalTokens: 75000000, cost: '$3.15' }
{ tokensPerCall: 550, totalTokens: 550000000, cost: '$23.10' }
{ tokensPerCall: 10800, totalTokens: 54000000, cost: '$2.27' }

The first line is 100,000 support tickets of about 800 characters, each with five triage questions like category, severity and whether the customer wants a refund. That’s 75 million input tokens, about $3.15.

The second is 1 million product reviews of about 400 characters, with three questions each (sentiment, reports a defect, mentions shipping): $23.10.

The third is 5,000 contracts of about 40,000 characters with ten questions each. Every call is big, but there are few of them, so the total is $2.27.

To see how many tokens one of your inputs uses, paste a sample into the token counter. It doesn’t use Jev’s tokenizer, so treat the result as a rough count.

Why is one call with many questions cheaper than many calls?

The state is billed once per request, not once per question. Ask 13 questions about a document in 13 calls and you pay for the document 13 times. Ask them in one call and you pay for it once.

The Parallel questions cookbook measured this on the 53,777-character article, with 13 questions of all three types:

• One call with all 13 questions: $0.000497, about 11,800 input tokens, 0.27 seconds.
• 13 calls with one question each: $0.006090, about 145,000 input tokens, 2.71 seconds.

That’s 12.2x cheaper and 10x faster, with the same answers. The test ran on jev-1.12, the model before the current one.

The speed number adds up the 13 calls as if you ran them one after another, so firing them in parallel closes most of that gap. The cost gap stays, because you still send the article 13 times. With a short state, like a tweet, the saving comes mostly from the fixed cost of every call you don’t make.

My advice is to put every question you might need about an input in one request, even the ones that only matter for some inputs, and let your code ignore the answers it doesn’t use. TypeSafe calls this speculative fan-out.

How do I log the cost of each call in code?

In the JavaScript SDK (@typesafe-ai/sdk, Node.js 20 or newer), every systemOne() call returns usage next to the answers. We can wrap the price math in a small helper that also keeps a running total:

import { choice, noul, TypeSafeClient } from '@typesafe-ai/sdk'

const PRICE_PER_MILLION = 0.042
const client = new TypeSafeClient()

let totalCost = 0

function trackCost(usage) {
  const cost = (usage.input_tokens / 1_000_000) * PRICE_PER_MILLION
  totalCost += cost
  console.log(`${usage.input_tokens} input tokens, $${cost.toFixed(8)} (total $${totalCost.toFixed(6)})`)
}

const { answers, usage } = await client.systemOne({
  state: { review: 'The headphones sound great, but the left ear cup cracked after two weeks.' },
  questions: {
    sentiment: choice('What is the overall sentiment of `review`?', {
      positive: 'Mostly happy with the product',
      mixed: 'Both praise and complaints',
      negative: 'Mostly unhappy with the product',
    }),
    reports_defect: noul('Does `review` describe a broken or defective product?'),
  },
})

trackCost(usage)
console.log(answers.sentiment.choice, answers.reports_defect.noul)

The client reads your key from TYPESAFE_API_KEY. Output tokens stay out of the math because they’re free. Call trackCost() after every request in a batch job and you’ll know what the job cost before the invoice does.

Through the Vercel AI SDK’s experimental_evaluate, the same number is in result.usage.inputTokens. It can be undefined, so fall back to 0 before multiplying.

What do the rate limits mean for throughput?

As of September 2026 the limits are 250,000 tokens per second and 1,200 requests per minute, and TypeSafe says they’re adjusting dynamically during early access. Go over either and you get a 429 Too Many Requests. The SDKs retry with backoff (the JavaScript SDK retries twice by default) and honor the retry-after header.

For small calls, the request limit is the one you’ll hit. 1,200 requests per minute is 20 per second, and 20 calls of 750 tokens is 15,000 tokens per second, far below the token limit. The token limit only matters when a single call is bigger than 12,500 tokens (250,000 divided by 20).

At one item per request, the workloads above take:

• About 83 minutes for 100,000 support tickets.
• About 14 hours for 1 million product reviews.
• About 4 minutes for 5,000 contracts, which at 10,800 tokens per call come close to both limits.

A simple way to stay under 20 requests per second is to send 20 at a time and wait a second between groups:

const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms))

async function processAll(items, handle) {
  const results = []
  for (let i = 0; i < items.length; i += 20) {
    const group = items.slice(i, i + 20)
    results.push(...(await Promise.all(group.map(handle))))
    await sleep(1000)
  }
  return results
}

handle is your function that calls systemOne() for one item.

You could also pack several items into one state and ask a set of questions per item. That means fewer requests and one fixed cost shared by many items. The catch is accuracy: the docs warn that answers get worse as the state fills with material unrelated to the question, and a state holding 20 reviews is mostly unrelated to any single one. Test it against one-item requests on your own data first.

Does Jev cost the same on Vercel AI Gateway?

Yes. Vercel’s model page lists typesafe-ai/jev at $0.042 per million input tokens with free output, and Vercel’s pricing docs say the Gateway adds no markup and no platform fee on tokens.

It’s also the easiest way to try Jev for free. Every Vercel team gets $5 of AI Gateway credit per month on the free tier, and Jev is one of the models the free tier can use. $5 covers about 119 million input tokens, more than the 100,000 tickets above.

My Vercel AI Gateway guide covers the setup. With AI_GATEWAY_API_KEY set, you pass 'typesafe-ai/jev' as the model to experimental_evaluate in AI SDK 7.

Is there a free tier from TypeSafe?

Not one that TypeSafe advertises. As of September 2026, neither typesafe.ai nor the docs mention a free tier or free credits for the direct API. The only thing TypeSafe calls free is output tokens.

As of late September 2026, TypeSafe has paused new signups because of demand, while existing accounts keep working. Once you have an account, the console shows your token consumption on its Usage page, and its Playground lets you try questions on your own data before writing code. I cover the console and the first request in how to get access to Jev and an API key.

What about enterprise plans?

The Models page says higher rate limits are available on custom and enterprise plans, and that zero data retention (ZDR) is offered to enterprise customers. TypeSafe doesn’t publish prices for those plans, so you have to ask sales@typesafe.ai.

How does Jev compare with LLM input prices?

TypeSafe’s homepage claims a “238x lower input price than Claude Fable 5.1”. That matches Anthropic’s pricing page as of September 2026: Fable 5.1 input costs $10 per million tokens, and $10 divided by $0.042 is 238.

TypeSafe’s launch post puts LLM input prices between $0.20 and $10 per million tokens, which makes Jev 5 to 240 times cheaper on input depending on the model.

The real gap is smaller than the headline, for a few reasons. Each model has its own tokenizer and needs its own prompt, so the same ticket is a different number of tokens everywhere. LLM providers also discount repeated input: on Anthropic’s pricing page a cache hit costs $0.25 per million tokens on Fable 5.1 and $0.20 on Opus 5.5, and its batch processing saves 50%. If your prompt is mostly a cached prefix, the difference shrinks a lot.

Will Jev cut my AI bill?

Only the part of the bill spent on decisions.

Split your AI spending into two piles. One is generation: replies, summaries, code, anything where you need text back. Jev can’t do any of that. The other is decisions like classify, route, score, check and filter, and that’s the only pile Jev can take over.

The most you can save is the size of that pile. Say you spend $2,000 a month on LLM calls and $300 of it goes to classifying tickets. Moving the classification to Jev saves close to $300, which is 15% of the bill. If decisions are 60% of your spending, the savings are much bigger.

Count the whole pipeline too. Retries cost money, and so does any LLM step before or after Jev, or a person reviewing the answers Jev wasn’t confident about.

To get your own numbers, take one decision you already pay an LLM for, run Jev beside it on a day’s worth of inputs, log every call with trackCost(), and compare the two totals.

Want me to talk about your product? You can sponsor this site.