
Jev (TypeSafe) API
jevJev is TypeSafe's System One decision model, released on 15 September 2026. It does not generate text: you send your application's state (a string, JSON object or array) plus a map of typed questions, and it returns one answer per question — choice picks one of up to 255 labelled options, score places the state on a 2–10 level scale you describe, noul returns the probability that a statement is true — each with a full probability distribution and a confidence. Every question is evaluated against the same state in parallel, so adding questions barely changes latency. On apimodels the endpoint is POST https://api.apimodels.app/v1/systemone with exactly TypeSafe's request and response, so TypeSafe's official Python SDK works with only base_url and the key changed. $0.05 per million input tokens, output free, billed per token with no per-call minimum; failed calls are not charged. It replaces the LLM call in classification, routing, triage and scoring pipelines; samples whose confidence falls below your threshold can still be handed to an LLM.
Jev does not generate text. You send your application state plus a map of typed questions and get one answer per question, with a full probability distribution and a confidence. Every question is evaluated against the same state in parallel. The request and response are identical to TypeSafe's API — the official SDK works with only base_url and the key changed.
Endpoint
Authorization: Bearer YOUR_API_KEY. This is not /v1/chat/completions — an OpenAI SDK pointed here will not work.
cURL
A request we actually sent on 2026-09-22: one ticket, two questions (which queue, and is it urgent).
curl https://api.apimodels.app/v1/systemone \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "jev",
"state": "Support ticket: I was charged twice for my September invoice and need one of the payments refunded.",
"questions": {
"queue": {
"type": "choice",
"instructions": "Which support queue should handle this ticket?",
"criteria": {
"billing": "Payments, invoices, charges and refunds",
"bug": "Something in the product is broken",
"account_access": "Login, password or permission problems",
"other": "Anything else"
}
},
"urgent": {
"type": "noul",
"instructions": "The customer needs a response within the hour."
}
}
}'
# 385 input tokens billed at $0.05 per 1M = $0.00001925; output is freeResponse (verbatim)
Keyed by your question ids; choice carries the full distribution and a confidence, noul is a number in 0–1; only input_tokens is billed.
{
"model": "jev-1.13.0",
"answers": {
"queue": {
"type": "choice",
"choice": "billing",
"confidence": 1.0,
"probabilities": { "billing": 1.0, "bug": 0.0, "account_access": 0.0, "other": 0.0 }
},
"urgent": { "type": "noul", "noul": 0.29 }
},
"usage": { "input_tokens": 385, "output_tokens": 63 }
}Python
TypeSafe's official SDK — only base_url and the key change.
# pip install typesafe-sdk (TypeSafe's official SDK: only base_url and the key change)
import os
from typesafe_sdk import Choice, Noul, TypeSafeClient
with TypeSafeClient(
base_url="https://api.apimodels.app",
api_key=os.environ["APIMODELS_API_KEY"],
) as client:
result = client.system_one(
state="Support ticket: I was charged twice for my September invoice and need one of the payments refunded.",
questions={
"queue": Choice(
instructions="Which support queue should handle this ticket?",
criteria={
"billing": "Payments, invoices, charges and refunds",
"bug": "Something in the product is broken",
"account_access": "Login, password or permission problems",
"other": "Anything else",
},
),
"urgent": Noul(instructions="The customer needs a response within the hour."),
},
)
print(result.choices["queue"].choice) # billing
print(result.nouls["urgent"].noul) # a probability, e.g. 0.29Node.js
const res = await fetch("https://api.apimodels.app/v1/systemone", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.APIMODELS_API_KEY}`,
"Content-Type": "application/json",
},
body: JSON.stringify({
model: "jev",
state: "Support ticket: I was charged twice for my September invoice and need one of the payments refunded.",
questions: {
queue: {
type: "choice",
instructions: "Which support queue should handle this ticket?",
criteria: {
billing: "Payments, invoices, charges and refunds",
bug: "Something in the product is broken",
account_access: "Login, password or permission problems",
other: "Anything else",
},
},
urgent: { type: "noul", instructions: "The customer needs a response within the hour." },
},
}),
});
const { answers, usage } = await res.json();
console.log(answers.queue.choice, answers.queue.confidence); // billing 1.0
console.log(answers.urgent.noul); // 0.29
console.log(usage.input_tokens); // 385 — the only thing billedThree question types
| type | You provide | You get back |
|---|---|---|
| choice | instructions + criteria: up to 255 "option: description" pairs | choice (the selected option), confidence, probabilities (one per option) |
| score | instructions + criteria: a 2–10 level scale, one description per level | score (the level), confidence, probabilities (one per level) |
| noul | instructions: a statement to judge | noul: the probability the statement is true (0–1) |
Billing
- $0.05 per 1M input tokens, output free; billed on the input_tokens the upstream reports, with no per-call minimum.
- Failed calls are free. Upstream 422s about question counts, criteria sizes or the 64k-token per-request budget are passed through verbatim.
- The 385-token request above costs $0.00001925; a million such decisions cost about $19.
Not a Chat Model
Send a state plus typed questions; get answers with probabilities and confidence, not generated text
Three Question Types
choice picks one of up to 255 options, score places the state on a 2–10 level scale, noul returns the probability a statement is true
Output Is Free
$0.05 per 1M input tokens, output free, billed per token with no per-call minimum; failed calls free
Same API as TypeSafe
POST /v1/systemone with identical request and response; the official SDK works with only base_url and key changed
About Jev
Jev is a Large Language Model API provided by TypeSafe. Jev is TypeSafe's System One decision model, released on 15 September 2026. It does not generate text: you send your application's state (a string, JSON object or array) plus a map of typed questions, and it returns one answer per question — choice picks one of up to 255 labelled options, score places the state on a 2–10 level scale you describe, noul returns the probability that a statement is true — each with a full probability distribution and a confidence. Every question is evaluated against the same state in parallel, so adding questions barely changes latency. On apimodels the endpoint is POST https://api.apimodels.app/v1/systemone with exactly TypeSafe's request and response, so TypeSafe's official Python SDK works with only base_url and the key changed. $0.05 per million input tokens, output free, billed per token with no per-call minimum; failed calls are not charged. It replaces the LLM call in classification, routing, triage and scoring pipelines; samples whose confidence falls below your threshold can still be handed to an LLM. Through APIMODELS platform, you can access this model via a unified API with transparent pay-as-you-go pricing. Current pricing: Input: $0.05, Output: $0.00 per 1M tokens.
Key Features
- Not a Chat Model -- Send a state plus typed questions; get answers with probabilities and confidence, not generated text
- Three Question Types -- choice picks one of up to 255 options, score places the state on a 2–10 level scale, noul returns the probability a statement is true
- Output Is Free -- $0.05 per 1M input tokens, output free, billed per token with no per-call minimum; failed calls free
- Same API as TypeSafe -- POST /v1/systemone with identical request and response; the official SDK works with only base_url and key changed
Use Cases
Chatbot & Customer Support
Build intelligent conversational systems to automatically answer user queries and improve service efficiency.
Content Generation
Automatically write articles, emails, ad copy, and other text content to boost productivity.
Code Assistant
Assist with code writing, debugging, and code review to accelerate software development.
Data Analysis
Understand and analyze unstructured data, extract key insights, and generate summary reports.
Why APIMODELS
- Unified API -- One API key to access all models, no need to register on multiple platforms
- Transparent Pricing -- Pay-as-you-go with per-call pricing published on every model page, ideal for indie developers and startups
- Instant Access -- Start using immediately after signup, supports Stripe and Alipay payments
- Full Documentation -- Detailed API docs with code examples in cURL, Python, and Node.js
Frequently Asked Questions
How much does Jev cost?
Jev is available through APIMODELS at: Input: $0.05, Output: $0.00 per 1M tokens. Billing is pay-as-you-go — you only pay for what you generate.
How to use Jev API?
Sign up at APIMODELS, get your API key, and call our unified API endpoint. We provide detailed API documentation with code examples in cURL, Python, and Node.js.
What is the difference between APIMODELS and the official TypeSafe API?
APIMODELS offers the same Jev model through our aggregation platform. We provide a unified API interface so you do not need separate accounts for each provider - one API key to access all models.
What is Jev, and who makes it?
Jev is a decision model from TypeSafe — a System One model, not a chat model, and unrelated to other products or abbreviations that share the name. You send your application state together with a few typed questions (choice, score or noul), and one call returns an answer per question with its probability distribution and confidence, all evaluated in parallel. It fits work where the output is a judgement rather than text: classification, scoring, routing. On apimodels you call it at POST /v1/systemone; input is $0.05 per million tokens and output is free.
Is Jev a chat model? What does it return?
No. Jev is a decision model: you send a state (a string, JSON object or array) and a map of typed questions, and it returns one answer per question with a full probability distribution and a confidence — choice picks one of your labelled options, score places the state on a 2–10 level scale you describe, noul gives the probability that a statement is true. There is no generated text, no prompt and no streaming.
How is Jev billed on apimodels?
Input is $0.05 per million tokens and output is free. We bill the exact input token count the upstream reports, with no per-call minimum, and failed calls are not charged. The same key and balance cover every other model on the site, so there is no separate TypeSafe account to open.
How do I call Jev on apimodels?
POST https://api.apimodels.app/v1/systemone with Authorization: Bearer YOUR_API_KEY and a JSON body of {"model":"jev","state":...,"questions":{...}}. The request and response are identical to TypeSafe's API, so TypeSafe's official Python SDK works once you set base_url to https://api.apimodels.app and pass your apimodels key. An OpenAI SDK pointed at this endpoint will not work — it is not a chat completion.
When should I use Jev instead of an LLM?
When the output is a label, a level or a yes/no probability rather than prose: ticket routing, content classification, lead scoring, moderation flags, feature gating. Jev answers every question in one call, in parallel, returns probabilities you can threshold directly, and costs a small fraction of an LLM call because output is free. Keep an LLM for anything that has to be written, and hand Jev answers below your confidence threshold to it.
How does Jev compare to other Large Language Model models?
On APIMODELS, Jev runs alongside 60+ models on one API key and one balance, so choosing is about fit, not lock-in. It supports Decision Model, Probabilities, Output Free, TypeSafe SDK Compatible, and you can weigh it on price and capability against other Large Language Model models, then switch by changing a single model-name string — no new account or integration. Browse every Large Language Model option with live pricing at apimodels.app/models.
What can Jev do?
Jev supports: Decision Model, Probabilities, Output Free, TypeSafe SDK Compatible. See the APIMODELS docs for full parameters and call examples.
Can I access the Jev API from anywhere (incl. China)?
Yes. APIMODELS exposes Jev through a single unified API and one key — no separate provider accounts, and no need to handle each provider's regional network access yourself.
What payment methods are supported?
We support Stripe (Visa, Mastercard, and other international cards) and Alipay. Credits are available instantly after payment.
Related models
Related reading
How to get access, regional availability, and how this model compares with its alternatives.