How to try Jev: playground, API key, and first request.

Two ways to try Jev

The playground on the Jev Guide homepage previews the same sample messages. TypeSafe also runs its own playground in the TypeSafe console, where you paste text as the state and add your own questions. Its quickstart says to open it and log in, so it needs a TypeSafe account, and does not say whether playground runs count toward billed usage.

What you need

• A TypeSafe account and an API key. The next section covers both.
• A terminal with curl for steps 1 and 2.
• Node.js 20 or newer for step 3 in TypeScript, or Python 3.10 or newer for the Python tutorial.

Get an API key

1. Sign in at the TypeSafe console with Google or an emailed one-time code.
2. Create a key on the Keys page, the link TypeSafe's quickstart gives for getting an API key.
3. Store it as a server-side environment variable named TYPESAFE_API_KEY: an .env file listed in .gitignore, or your platform's secret manager. Both the curl commands below and the official SDKs read it from there. For a quick test in a terminal:

export TYPESAFE_API_KEY="your-key-here"

Not public: TypeSafe describes Jev as available in early access, and we found no public waitlist form. Its public pages do not say whether every account gets immediate API access, whether new accounts get trial credit, or whether a payment method is needed before the first call. The console blocks automated requests, so this guide could not check it directly; your console shows your own account's status.

Step 1: check that your key works

Before writing any question, list the models your key can use. This call asks Jev nothing, so it separates a key problem from a request problem.

curl https://api.typesafe.ai/v1/models \
  -H "Authorization: Bearer $TYPESAFE_API_KEY"

A working key returns a models list. It currently lists the aliases, such as jev-latest, each with a description and release date. A 401 here means the key or the header is wrong; see “When the first call fails” below.

{
  "models": [
    { "name": "jev-latest", "description": "...", "release_date": "..." },
    { "name": "jev-preview", "description": "...", "release_date": "..." }
  ]
}

Step 2: send your first question

Every call goes to one endpoint, POST /v1/systemone, with three fields: state (the text Jev judges), model, and questions. The simplest question is a Noul, a yes/no question. The key you give it, refund_requested here, is for your code only. TypeSafe does not send it to the model, so the full question goes in instructions.

curl https://api.typesafe.ai/v1/systemone \
  -H "Authorization: Bearer $TYPESAFE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "state": "I was charged twice for order A-104. Please refund the duplicate.",
    "model": "jev-latest",
    "questions": {
      "refund_requested": {
        "type": "noul",
        "instructions": "Does the customer request a refund?"
      }
    }
  }'

Reading the response

{
  "model": "jev-1.13.0",
  "answers": {
    "refund_requested": { "type": "noul", "noul": 0.97 }
  },
  "usage": { "input_tokens": 300, "output_tokens": 20 }
}

• answers has one entry per question, under the key you chose. Its type matches the question you asked.
• noul is the probability that the answer is yes: near 1 is a strong yes, near 0 a strong no, near 0.5 undecided. A Noul answer has no separate confidence field. Your code picks the threshold.
• model is the versioned model that answered. The jev-latest alias moves to new releases, so log this value if you tune thresholds.
• usage.input_tokens is what you pay for. Output tokens are documented as free.

Choice and Score questions return more: a probability for every option or level, plus a confidence value derived from how that probability is spread. The TypeScript guide walks through a Choice answer in full.

Step 3: the same request in TypeScript or Python

Install the official SDK with npm install @typesafe-ai/sdk. new TypeSafeClient() reads TYPESAFE_API_KEY automatically and retries 429 and 529 responses with backoff. Keep the call on a server: the SDK's dangerouslyAllowBrowser option, which would expose your key to every visitor, defaults to false.

// Guide: your first Jev request, one yes/no (Noul) question.
// Requires Node.js 20+ and TYPESAFE_API_KEY in the environment.
//   npm install @typesafe-ai/sdk
// Source: https://jevguide.ai/guides/getting-started. Not executed against the live API by Jev Guide.
import { noul, TypeSafeClient } from "@typesafe-ai/sdk";

const client = new TypeSafeClient(); // reads TYPESAFE_API_KEY, defaults to jev-latest

const { answers } = await client.systemOne({
  state: "I was charged twice for order A-104. Please refund the duplicate.",
  model: "jev-latest",
  questions: {
    refund_requested: noul("Does the customer request a refund?"),
  },
});

// A Noul answer is one probability that the answer is yes. It has no separate confidence.
const { noul: refundRequested } = answers.refund_requested;
console.log(refundRequested > 0.5 ? "Refund requested" : "No refund requested", refundRequested);

Working in Python? The Jev Python tutorial installs typesafe-sdk (Python 3.10 or newer), reads the same TYPESAFE_API_KEY, and builds one runnable script that classifies a support message, scores its urgency, and checks whether it asks for a refund.

When the first call fails

Errors come back as standard HTTP status codes with a JSON body saying what went wrong. To confirm the key is set without printing it, run [ -n "$TYPESAFE_API_KEY" ] && echo set in the same terminal. In TypeScript, the SDK throws a matching subclass: AuthenticationError, UnprocessableEntityError, RateLimitError, or InternalServerError. See the TypeScript error-handling example or the Python one.

401 Unauthorized

The key is missing or invalid. Check that the header reads Authorization: Bearer followed by the key, that TYPESAFE_API_KEY is set in the shell or process making the call, and that the key has not been revoked in the console.

422 Unprocessable Entity

The body failed validation, and the response body names the field. On a first call this is usually a missing required field (state, model, or questions), a question without type or instructions, or a question over the documented limits: more than 10 Score levels or more than 255 Choice options.

429 Too Many Requests

You are over the rate limit. The official SDKs retry with backoff by default; with curl, wait and retry. TypeSafe notes that its limits are adjusting and can change without notice.

529 Overloaded

TypeSafe is temporarily overloaded. The official SDKs retry with backoff by default; with curl, retry after a short delay.

If step 1 works but step 2 fails, the key is fine and the problem is in the request body. If both fail with 401, fix the key first.

What it costs

As of docs.typesafe.ai/models on 2026-09-25, direct API access bills $0.042 per million input tokens, and output tokens are free. Input means the state plus every question's instructions and criteria. A small first request like the one above is a few hundred tokens, a tiny fraction of a cent.

The docs mention custom and enterprise plans for higher rate limits, but they do not document a subscription, free credits, a trial, or a minimum payment either way. Jev Guide itself is free and has no subscription; runs in our recipes with your own key are billed by TypeSafe to your account, like any other API call.

For the formula, cost tables, monthly examples, and the full subscription question, see Jev pricing: does Jev require a subscription?

Official Jev documentation

TypeSafe AI publishes the official docs at docs.typesafe.ai. Use them as the authority on fields, limits, and prices. Jev Guide is independent and not affiliated with TypeSafe; our pages are worked examples that link back to the official source.

• HTTP API reference

  Exact request and response fields, answer types, question limits, and error codes. Use it when you call the endpoint directly from any language.

  Worked example: First request with curl

• Python SDK

  Installing typesafe-sdk, the sync and async clients, question and answer types, retries, and exceptions.

  Worked example: Jev Python tutorial

• JavaScript / TypeScript SDK

  Installing @typesafe-ai/sdk, client configuration, typed question helpers, and error classes.

  Worked example: Jev TypeScript guide

• Choice

  “Pick one option from a fixed list.” Routing, labeling, and any single pick from known options.

  Worked example: Route a message

• Score

  “Rate the state along ordered levels.” Urgency, severity, or quality against a rubric you write.

  Worked example: Score urgency

• Noul

  “Get the probability that a statement is true.” Yes/no checks where you want P(yes), not a label.

  Worked example: Check a reply

• Models

  Current model IDs and aliases, GET /v1/models, pricing, rate limits, and input limits. Check it before budgeting.

  Worked example: Jev pricing explained

Want more tasks to adapt? Browse the recipes: six tasks, each with sample inputs and copyable code.

FAQ

How can I try Jev?

Open the message routing recipe to explore sample messages, or paste your own TypeSafe API key there to run your own text. To build with it, get a key from the TypeSafe console and run the two curl commands above. TypeSafe's own console playground is another option once you have an account.

Do I need an API key?

Not to explore our sample messages, but those answers are illustrative, not from Jev. Anything else that calls Jev needs a TypeSafe account: running your own text with your key, the API, the SDKs, and TypeSafe's console playground.

Can I use Jev like a chatbot?

No. Jev does not write replies or hold a conversation. It answers typed questions about the state you send, and your code decides what to do with the answer. For when to use Jev or a general-purpose LLM, see Jev vs LLMs.

Where are the official Jev docs?

At docs.typesafe.ai, published by TypeSafe AI. Jev Guide is an independent site. See Official Jev documentation for which page to use for which task.

What should I do if my first request fails?

Run the step 1 key check first. If it returns 401, the key is missing or wrong in the shell that sent it. If the key check works but your request fails with 422, the body failed validation and the response names the field. 429 or 529 means wait briefly and retry. Details are in When the first call fails.

Sources and verification

• Introduction: what Jev is.
• Quickstart: the console playground, the API-key link, and the curl request shape.
• Models: GET /v1/models, aliases, pricing, rate limits, and plan mentions.
• HTTP API reference: required fields, question limits, and the error table above.
• Primitives and Noul: Choice, Score, and Noul, and why a Noul has no confidence field.
• Client SDKs: the Python and JavaScript/TypeScript SDKs and their default retries.
• typesafe.ai: the early-access description and the console sign-in link.
• @typesafe-ai/sdk on GitHub: pinned at v0.6.0 in this site's package.json.

Reviewed against the sources above on 2026-09-25; the TypeSafe console could not be loaded for this review. The TypeScript file is compiled by this site's build against SDK 0.6.0, and the curl commands match the API reference. None of them has been executed against the live API by this guide, and the JSON responses are illustrative. What the recipes offer without a key is described from this site's own code.