Jev API Getting Started: What the Free $5 Credit Buys

Jev API access is now open to everyone. TypeSafe AI has dropped the Jev waitlist, and new users get a free $5 credit, about 119 million input tokens at list price. You sign in at console.typesafe.ai, create a key, install one package, and make your first call in minutes. This guide shows that first call, what the credit really buys, and what to test first.

Key Takeaways

• Jev is open to all users with no waitlist, a week after TypeSafe AI launched it in early access.
• New users get a $5 credit. At $0.042 per million input tokens, with output free, that's about 119 million input tokens.
• In practice, that's roughly 400,000 short calls, or about 85,000 calls on ticket-sized inputs.
• Your first Jev API call takes one package, one API key, and a few lines of Python.
• Spend the credit on a labeled test of your own decisions, not on demos. That's what tells you if Jev fits.

What Changed When Jev Opened to Everyone?

The waitlist is gone. Anyone can now sign up and start calling Jev right away.

Reported fact: TypeSafe AI launched Jev on September 15, 2026, alongside a $40 million seed round. At launch, access ran through a waitlist, as MarkTechPost noted on September 19. On September 21, 36Kr reported that Jev is now open to all users with no waitlist, and that every registered user gets a $5 credit.

Pricing hasn't changed. TypeSafe's models page still lists input at $0.042 per million tokens, and output tokens are free. The current model is jev-1.13.0, which the jev-latest alias points to.

If Jev is new to you, it isn't a chatbot. It's what TypeSafe calls a System One model. You give it a state, such as a support ticket, plus questions you define. It returns typed answers with probabilities, not text.

We covered how that fits an agent in our guide to System One models, and how it stacks up against frontier models in Jev vs Fable 5.1 vs GPT-6 Astra.

How Far Does the Free Jev API Credit Go?

The Jev free credit goes further than most trials, because Jev only bills input tokens. Here's the arithmetic.

The credit is $5. At $0.042 per million input tokens, that buys about 119 million input tokens. That matches the "about 120 million tokens" in the announcement. For comparison, $5 at a frontier model's $10 per million input price buys 500,000 input tokens, before any output.

Tokens aren't calls, though. The useful number is how many decisions you get. TypeSafe's own API reference shows one short yes-or-no question about a one-line message using 296 input tokens. So even a tiny call carries some fixed overhead.

Here's what the credit covers at a few input sizes. The first row uses TypeSafe's example. The others are our round-number estimates, so measure your own.

Input per call	Example	Cost per call	Calls on $5
296 tokens	One short question on a one-line message	About $0.0000124	About 402,000
1,400 tokens	A support ticket with three questions	About $0.0000588	About 85,000
5,300 tokens	A few pages of a contract or report	About $0.00022	About 22,500
64,000 tokens	A full request at the context limit	About $0.0027	About 1,860

There's a practical ceiling too. The documented rate limit is 1,200 requests per minute. At that pace, 402,000 short calls would take over five and a half hours. For a trial, that's plenty.

We couldn't confirm whether the credit expires or whether a card is needed to claim it. Check the billing page in the console before you plan a big test around it.

How Do You Make Your First Jev API Call?

You need a TypeSafe account, an API key, and Python 3.10 or newer. The whole setup takes a few minutes.

Here are the steps from TypeSafe's quick start:

• Sign in. Go to console.typesafe.ai and continue with Google or an email code.
• Try the playground. The console has a playground where you paste text and add questions. It's the fastest way to get a feel for the model before you write code.
• Create a key. Open the keys page in the console and create an API key.
• Install the SDK. Run the install command below, then set your key as an environment variable.

pip install typesafe-sdk
export TYPESAFE_API_KEY="your-key-here"

The client reads that variable on its own and uses the jev-latest model by default. Here's a first call that routes a support ticket and flags urgency in one request:

from typesafe_sdk import Choice, Noul, TypeSafeClient

with TypeSafeClient() as client:
    response = client.system_one(
        state="I was charged twice for one order. Please fix this today.",
        questions={
            "team": Choice(
                instructions="Which team should handle this?",
                criteria={
                    "billing": "Charges, refunds, invoices",
                    "shipping": "Delivery status, delays, lost packages",
                    "other": "Anything else",
                },
            ),
            "urgent": Noul(instructions="The customer needs a fast reply"),
        },
    )

team = response.answers["team"]
print(team.choice, team.confidence)
print(response.answers["urgent"].noul)

Notice the "other" option. TypeSafe recommends adding one whenever your list might not cover every case. Without it, Jev has to pick the closest wrong answer.

Prefer JavaScript? There's an official SDK for that too. You can also call the REST endpoint directly with a bearer token. Both are covered in the API reference.

How Do You Read a Jev API Response?

Every answer comes back typed, with the numbers you need to decide what to trust. You don't parse any text.

For a Choice question, you get three fields:

• choice. The option with the highest probability, such as "billing".
• confidence. A number from 0 to 1. It's high when the probability sits on one option and low when it's spread out.
• probabilities. The full spread, such as billing 0.61 and shipping 0.35.

A Noul question returns a single probability between 0 and 1 that the statement is true. A Score question returns a position on your scale, plus confidence and probabilities for each level. The raw response also includes a usage count of input and output tokens, so you can track cost per call.

The confidence number is the part that matters most. TypeSafe's confidence guide suggests acting on its own only above about 0.9 for high-stakes actions. Below about 0.5, it says not to act on the answer alone. Between those, ask for confirmation or flag the case for review.

Here's that routing as code. The three functions are placeholders for your own logic:

if team.confidence >= 0.9:
    route_to(team.choice)
elif team.confidence >= 0.5:
    route_with_review(team.choice)
else:
    send_to_person(ticket)

Treat those numbers as a start, not a rule. TypeSafe itself says to start with cautious thresholds and adjust them against your own data.

Which Question Type Should You Start With?

Start with the question type that matches a decision you already make. Jev has three, and each suits a different job.

Type	What it answers	Limits	Good first use
Noul	Is this statement true? Returns a probability.	One statement per question	Urgency flags, spam checks, policy checks
Choice	Which of these options fits? Returns one pick.	Up to 255 options	Ticket routing, intent detection, tagging
Score	Where does this sit on a scale? Returns a level.	2 to 10 levels	Severity, quality grades, lead scoring

For a first test, Noul is the easiest to check. You already know which past messages were spam or urgent. Choice is the best value once you trust it, because you can ask several questions about one input in a single call.

With Score, describe each level as a concrete situation, not an abstract degree. "Blocking issue with no workaround" works better than "very severe". TypeSafe's score docs give the same advice.

What Should You Test in Your First Week?

Spend the Jev free credit on your own data, not on demos. A demo tells you Jev works. Your data tells you if it works for you.

Here's a one-week plan that fits well inside $5:

• Day 1: explore. Use the playground on ten real examples from your work. Learn how wording changes the answers.
• Day 2: build a labeled set. Pull 200 to 500 past decisions where you know the right answer, such as tickets and the team that solved them.
• Day 3: run and measure. Run the whole set through the Jev API. Compare each answer with your label and record accuracy.
• Day 4: set thresholds. Sort the results by confidence. Find the level above which Jev is almost always right, and send everything below it to review.
• Day 5: compare costs. Run the same set through the model you use today. Compare cost per correct answer, not cost per call.
• Days 6 and 7: stress it. Add messy cases, mixed languages, and adversarial text. Note where it breaks.

A 500-example test at 1,400 tokens each is 700,000 input tokens. That's about 3 cents, so you can rerun it many times as you tune your questions.

This is the same method we use for any model change. Our guide to AI agent evaluation covers how to build the labeled set and keep it useful over time.

What Are Jev's Known Weak Spots?

TypeSafe publishes its own list of where Jev 1.13 struggles. That's unusual, and it's the best place to aim your stress tests.

From TypeSafe's Jev 1.13 limits page:

• Literal reading. It answers the question as written, not what you meant. Negations and scope words are taken at face value.
• Math and counting. It's not a calculator, and counting errors grow with the size of the list.
• Dates. It reads dates as text, so comparing them is unreliable, especially with mixed formats.
• Multi-step reasoning. A question about a property of a property needs several hops, and accuracy drops.
• Distracting detail. Long inputs full of unrelated text lower accuracy.
• Steering attempts. It doesn't treat input as hostile, so injected instructions can sway it.
• Consistency. A question and its opposite may not add up to 1.
• Text generation. It isn't trained to write, and it does badly if forced to.

Two practical fixes follow. First, do math, date checks, and counting in code, then ask Jev only the judgment part. Second, trim the input to what the question needs.

Language matters as well. The models page says English is the primary language. Other languages work, but with lower accuracy. If your users write in Vietnamese or another language, test those inputs as a separate group.

How Do You Handle Jev API Rate Limits and Errors?

Plan for limits from day one. They're generous but still moving.

TypeSafe lists rate limits for jev-1.13 at 250,000 tokens per second and 1,200 requests per minute. It also says these limits are adjusting as it adds capacity. Going over either one returns a 429 error.

The API reference lists four main errors:

• 401. Your API key is missing or wrong.
• 422. Your request failed validation, such as a missing field.
• 429. You've hit a rate limit. Back off and retry.
• 529. TypeSafe is overloaded. Retry after a short delay.

The official SDKs retry 429 and 529 errors with growing delays, so you don't have to write that part. What you do need is a fallback. If Jev stays down, your agent should send the decision to another model or a queue, not stall.

The simplest design is a thin wrapper around every Jev API call. It tries Jev, and on repeated failure it calls your backup model with the same question. Our guide to human review loops shows how to route the cases no model should decide alone.

Where Should You Sign Up, and What Should You Avoid?

Use only TypeSafe's own sites. Launch buzz has brought out a crop of unofficial ones.

The official places are the TypeSafe console at console.typesafe.ai and the docs at docs.typesafe.ai. The Python package is typesafe-sdk.

Since launch, several websites with "Jev" in their names have appeared. Some offer playgrounds or keys through other services. We can't verify who runs them.

A few simple rules keep you safe:

• Get keys only from the official console. Never paste a TypeSafe key into a third-party site.
• Check the package name. Install typesafe-sdk and confirm it matches the name in the official docs.
• Watch for fake credits. The $5 credit comes with your TypeSafe account. You don't need another site to claim it.

Is the Jev API Ready for Production?

For some jobs, yes, with guardrails. For critical paths, not yet on its own.

Open access makes Jev easy to try, but it doesn't make TypeSafe an established vendor. The company came out of stealth on September 15, 2026. Its rate limits are still changing. Free output tokens are a launch price, and nothing guarantees they'll last.

Here's how we'd weigh it:

• Good fit now: high-volume, low-stakes decisions such as tagging, triage, spam checks, and first-pass grading.
• Good fit with review: guardrails on agent tool calls, with low-confidence cases sent to a stronger model or a person.
• Not yet: decisions where one wrong answer is costly, unless a person or second model checks them.
• Always: wrap Jev behind your own interface, so switching providers is a config change and not a rewrite.

Speed claims deserve the same care. TypeSafe cites response times of 70 to 500 milliseconds and large speed-ups over frontier models, using its own tests. Independent results so far are promising but narrow, which we covered in our Jev comparison. Your own labeled test is the number that counts.

How Van Data Team Helps Teams Test the Jev API Safely

We help teams find out, fast and cheaply, whether a new model like Jev earns a place in their stack. That means mapping the decisions in your workflows, building labeled test sets from your real data, and measuring cost per correct answer across Jev and the models you already use.

When a model passes, we wire it in with confidence thresholds, fallbacks, and review queues, so a bad day at one vendor doesn't stop your agents. The Jev free credit makes a first Jev API test almost free. Our work on AI agent evaluation and AI agent development cost is a good place to start.