Jev API: Endpoint, Pricing & cURL Example

By William Zhu & the InfiniSynapse Data Team · Published: 2026-09-23 · Last updated: 2026-09-26 · Last verified: 2026-09-26 · Next review: 2026-12-23 · Editorial standards · Corrections

Author credentials: William Zhu is Cofounder of InfiniSynapse, with a public engineering identity at GitHub @allwefantasy. This developer guide was checked on 2026-09-26 against TypeSafe, OpenRouter, Cloudflare, and Vercel documentation. It describes a proposed architecture and does not claim that InfiniSynapse currently integrates Jev.

Table of Contents

• TL;DR
• Integration status and evidence boundary
• Jev API endpoint and a cURL example
• Keys, price, and access routes
• What Noul, Choice, and Score return
• Prerequisites
• Seven executable integration steps
• SDK clients versus a raw HTTP call
• Failures, retries, and idempotency
• Safe fallback matrix
• Security controls and the reference adapter
• Frequently Asked Questions
• Conclusion

TL;DR

Direct answer: The Jev API direct call is POST https://api.typesafe.ai/v1/systemone with a server-side bearer key, a model, shared state, and named Noul, Choice, or Score questions. On 2026-09-26 the TypeSafe models page listed Jev 1.13 (jev-1.13.0) at $0.042 per million input tokens, with output tokens free. A probability may route a job. It must not grant permission to pay, delete, publish, or write production data.

This Jev API page completes a developer task: copy a bounded request, validate the typed response, record the resolved model, retry only transient failures, and keep idempotency on the business action. The downloadable conceptual TypeScript reference adapter implements that boundary with no third-party dependencies. It has not been run against InfiniSynapse or live TypeSafe credentials.

OpenRouter, Cloudflare, and Vercel reach the same question types with their own keys and URLs. A public 10-call check of the official endpoint, cited below, finished 4 of 10 calls, so this Jev API client needs a fallback before release.

Integration status and evidence boundary

As of the verification date, TypeSafe documents Jev as a System One model for narrow typed judgments. The official API reference documents the direct Jev API endpoint and bearer authentication. That is an interface fact, not an InfiniSynapse test.

Important: the architecture below is proposed. InfiniSynapse does not claim a current native Jev integration, production deployment, partnership, measured uptime, or first-party performance result. Before shipping, confirm the API, account terms, model availability, limits, and pricing in your own account.

For the runtime role before implementation, see Jev for AI agents. For an evidence-first release decision after implementation, use the separate Jev benchmark protocol rather than vendor multipliers.

Jev API endpoint and a cURL example

The direct Jev API request has three top-level fields: state (a string, object, or array of evidence), model (jev-latest or a pinned id such as jev-1.13.0), and questions (a map whose keys you choose). The matching answer returns under the same key. Send only the fields required to decide. Leave credentials, raw access tokens, and hidden authorization rules out of state, and treat user-controlled text inside it as untrusted data.

curl https://api.typesafe.ai/v1/systemone \
  -H "Authorization: Bearer $TYPESAFE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "state": {
      "job_id": "job_01J",
      "artifact_type": "weekly_revenue_report",
      "quality_checks": {
        "row_count_passed": true,
        "reconciliation_passed": true
      },
      "review_note": "Two regions use provisional FX rates."
    },
    "model": "jev-latest",
    "questions": {
      "needs_review": {
        "type": "noul",
        "instructions": "Does this evidence require manual review before release?"
      },
      "queue": {
        "type": "choice",
        "instructions": "Which review queue should receive this report?",
        "criteria": {
          "finance_review": "FX, revenue, or reconciliation concerns",
          "data_quality_review": "Row counts, schema, or source gaps",
          "ready_for_review": "No material issue is described"
        }
      }
    }
  }'

Keep $TYPESAFE_API_KEY on the server. This Jev API example is for a trusted backend. We did not execute this body against a live key. TypeSafe’s documented Noul sample has this shape:

{
  "model": "jev-1.13.0",
  "answers": {
    "is_urgent": { "type": "noul", "noul": 0.95 }
  },
  "usage": { "input_tokens": 296, "output_tokens": 20 }
}

Persist the returned model. The models page maps jev-latest and jev-preview to jev-1.13.0, and versioned ids are accepted. Pin a tested version for release, and store question_version with every answer. Overlapping labels can make a confident Jev API choice wrong.

Keys, price, and access routes

A direct Jev API key is a TypeSafe credential. Read it on the server from a secret manager. OpenRouter’s Jev hub says an OpenRouter key is enough for its two surfaces and that a separate TypeSafe account is not required there. Cloudflare’s Jev model card authenticates with a Cloudflare token. Vercel’s TypeSafe-compatible AI Gateway authenticates with an AI Gateway key or OIDC token. Swapping the key without swapping the base URL sends the call to the previous host.

Hosts checked on 2026-09-26 for this Jev API comparison are https://api.typesafe.ai/v1/systemone, https://openrouter.ai/api/alpha/decisions, https://openrouter.ai/api/v1/systemone, https://ai-gateway.vercel.sh/typesafe/v1/systemone, and Cloudflare’s account ai/run with model typesafe/jev.

Checked on 2026-09-26, TypeSafe prices Jev 1.13 at $0.042 per million input tokens ($42 per billion) and lists output tokens as free. The same page lists 250,000 input tokens per second and 1,200 requests per minute, and says those caps are still moving. Over either cap the direct Jev API returns 429. Cloudflare’s card listed the same input and output prices. OpenRouter publishes its own card and returns usage.cost. Do not copy one host’s price onto another.

Context budgets differ too. TypeSafe says 64k tokens per request and 32k for state plus the longest question. OpenRouter and Cloudflare both state 32,000 tokens. Record the host on the audit row, and do not fail over in silence. Vercel’s page says gateway calls are billed through AI Gateway.

What Noul, Choice, and Score return

The official primitives guide is the source of truth for field names. Every type shares type and instructions. Choice and Score also require criteria. The Jev API returns probabilities, not a sentence or a summary. Pair it with a generator model when the product needs prose.

Choice probabilities are documented as floats that sum to 1, and confidence is derived from that distribution. A valid Choice can still select the wrong queue. Type correctness is only the transport gate.

Keep arithmetic, dates, row counts, permissions, and schema checks in code. TypeSafe’s Jev 1.13 jaggedness note warns about numeric precision, counting, dates, literal wording, adversarial state, and long context. Check Jev request limits before treating 255 choices or a long state as safe for the task.

Prerequisites

The Jev API prerequisites are a server-side key for the host you call, a backend that can make HTTPS requests, a labeled set from your own domain, and an execution service that already enforces authorization. You also need a durable job id. Without that record, the Jev API result has nowhere auditable to live.

Define the decision before writing code

Write the decision in one sentence, list every allowed answer, price a false positive and a false negative, and choose the fallback before calling the Jev API. A sound first case is “may this report proceed to human review?” Approval to publish is a wider decision and stays off this call.

Seven executable integration steps

1. Accept a job, never a browser secret

The browser sends a job ID to your backend. The backend loads authorized, minimized state. The Jev API key remains in a server secret manager and is read into an environment variable at runtime. Never embed it in JavaScript delivered to a user.

2. Build a typed request

Construct state from allowlisted fields. Add the selected model and named questions. Reject an empty option set, duplicate labels, missing criteria, or an oversized state before the network call. Attach your internal decision_id and question version to the local record. Those fields are yours. They are not documented Jev API request fields.

3. Call one documented host

Send the Jev API bearer key and JSON to the one host selected above. The reviewed TypeSafe reference does not document an idempotency header, so the adapter does not invent one.

4. Validate structure before semantics

Require a successful HTTP status, JSON, a returned model, and an answer for every requested key. Choice values must be declared options with finite probabilities. Noul must be finite and between zero and one. Score needs a legend and level probabilities. The Jev API response passes only the transport gate here.

5. Convert the answer into an advisory decision

Map the validated answer to continue_to_review, escalate, or fallback. Do not map it directly to execute_payment or publish_report. Thresholds must come from held-out labels for the same task. If you have no validation set, default to escalation. The Jev API supplies the signal. Local mapping owns the operational meaning.

6. Persist an audit record

Store the job ID, decision ID, question version, requested model, returned model, provider host, minimized state hash, answer, probability distribution, threshold, route, latency, attempt count, and error class. Do not log the bearer token or raw sensitive state.

This record connects the call to the decision job, where sources, evidence, gates, and artifacts share one identity. The broader data infrastructure hub explains why that identity belongs in the runtime rather than a chat transcript.

7. Execute through a separate authorized service

After the advisory route, call a deterministic policy gate. That service verifies the actor, tenant, resource, current job state, approval status, and idempotency key. Only then may an allowed side effect occur. The Jev API never owns the credential or permission for that action.

SDK clients versus a raw HTTP call

TypeSafe documents a JavaScript client, @typesafe-ai/sdk, and a Python client, typesafe_sdk. Both can list models and call System One. Vercel’s gateway guide shows the migration that matters: set both the gateway key and baseURL to https://ai-gateway.vercel.sh/typesafe. Changing only the key leaves requests on the client’s default host. OpenRouter’s System One surface is the same kind of base-URL switch, with an OpenRouter key.

The Vercel AI SDK provider documentation shows another client shape: experimental_evaluate, evaluationModel('jev-latest'), and Choice, Score, and Boolean answers. That adapter uses boolean where the direct Jev API request uses noul. Do not mix those names in one validator.

Official docs say the vendor SDKs retry 429 and 529 with backoff by default. Cap that budget. Contract-test each primitive, unknown types, missing keys, bad probabilities, and non-JSON bodies, then test labeled ambiguous and adversarial cases. Report false positives separately from accuracy.

Run a shadow stage first. The Jev API writes a record while the existing route stays authoritative. Promote only after a human approves thresholds and fallback behavior.

Failures, retries, and idempotency

Classify failures before retrying

The official Jev API reference makes 401 and 422 terminal, and 429 and 529 retryable with backoff and jitter. Timeouts are unknown outcomes: record them and take the fallback in this table.

That fallback is supported by founder-reported operating evidence. In a public 10-call serial check during an 11-minute window, the official endpoint completed 4/10 calls. The six failures were one read timeout, two remote disconnects, two 503 responses, and one 529 system_overloaded. Successful calls took 0.64–1.61 seconds. This is a short observational window, not an uptime estimate, but it is enough to test every Jev API failure branch before release.

Use at most three attempts inside the job’s latency budget. Do not retry malformed requests, and never run an unbounded loop. HTTP semantics in RFC 9110 separate safe network retries from application side effects. They do not create business idempotency. A retry can still consume quota and return a different model result.

Put idempotency around execution

Derive an execution key from job_id + action_type + artifact_version. Insert it into a database table with a uniqueness constraint before the side effect. If the key already exists, return the prior outcome. The Jev API decision record may have several attempts. The downstream action must have at most one committed execution.

This distinction matters after a timeout. You may repeat a judgment. You must not repeat a payment, deletion, production write, or publication. Data ops covers the resume and audit path around the same job ID.

Safe fallback matrix

Figure. Illustrative fallback policy; production behavior must follow current API terms and local risk.

For the Jev API, fail closed means preserve the previous safe route. A report can remain a draft. A routing suggestion can enter a review queue. A dashboard can show “decision unavailable.”

Security controls and the reference adapter

Keep the Jev API key server-side, rotate it, restrict access to the service identity, and redact it from logs. OWASP’s API Security project is useful for reviewing broken authorization, resource consumption, inventory, and unsafe API consumption around the adapter.

Minimize state and define retention. Hash it when a hash is enough for audit. Otherwise encrypt the snapshot under the same access controls as the source. Record provider and resolved model, because an alias can move without a code deploy.

The downloadable TypeScript adapter includes Jev API request construction, timeout handling, status classification, bounded backoff, response checks, an audit-record shape, and a separate execution-idempotency key helper. It is conceptual and credential-free. Review it against current docs, your runtime, and your security policy before use.

Frequently Asked Questions

What endpoint does the Jev API use?

Bottom line: TypeSafe documents POST https://api.typesafe.ai/v1/systemone. OpenRouter, Vercel AI Gateway, and Cloudflare Workers AI publish different URLs and different keys. Verify the host you selected at implementation time.

What does one call cost?

Bottom line: On 2026-09-26 the direct Jev API price for Jev 1.13 was $0.042 per million input tokens, with output tokens free. Cloudflare’s card listed the same pair of prices. OpenRouter says to read its model page and usage.cost. Early-access prices can change.

Can I expose the API key in a frontend app?

Bottom line: No. A frontend secret is recoverable by users. Call the Jev API from a trusted backend and expose only your authorized job endpoint.

Should I retry every error?

Bottom line: No. On the direct Jev API, retry 429 and 529 with bounded exponential backoff. Fix 401 and 422 instead of retrying them.

Does a high confidence score authorize an action?

Bottom line: No. Confidence can route a decision. Authorization belongs to deterministic policy and, for high-risk actions, a human approval.

Does InfiniSynapse currently integrate Jev?

Bottom line: This article does not claim that. It presents a proposed architecture and an uncredentialed conceptual adapter for evaluation.

Conclusion

A production Jev API call is a narrow decision boundary: one host, a server-side key, minimized state in, a typed answer out, validation and audit in the middle, and deterministic authorization after it. Keep the published input price and the context budget attached to the host you actually call. Preserve the resolved model, retry only transient failures, and make downstream execution idempotent. A decision signal can improve routing without becoming the owner of the action.