Jev API key: get one here, or from TypeSafe and the gateways

Usage, per-call history and purchases are on your dashboard.

Where can you get a Jev API key?

All four reach the same Jev 1.13. TypeSafe's route is the model's own billing at $0.042 per million input tokens; the gateways add an account you may already have. The step-by-step for TypeSafe and the gateways is on getting Jev access.

Which Jev API key works on which host?

Only its own. We sent each key to each host on 2026-10-11; the refusals, verbatim:

Read the message, not just the 401. OpenRouter answers a key it did not issue with “Missing Authentication header” even when the header is there, which sends people hunting for a bug in their code; it means the key belongs to another host. The status codes for everything else are on Jev rate limits and errors.

How do you use and test a Jev API key?

Keep it in an environment variable on the server, never in browser code, and send it as a bearer token. TypeSafe's SDKs read TYPESAFE_API_KEY on their own. To check a TypeSafe key without spending anything, list the models; a 200 means the key is live:

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

For a key from this page, GET /api/keys with it as the bearer token returns your balance the same way. If a key leaks, rotate it where it was issued: TypeSafe's console, OpenRouter's key list, or PUT /api/keys here.

Use your own TypeSafe key

From code, send the key per request as X-TypeSafe-Key next to your Jagent key, on the REST API or the MCP server alike: Jev answers on your TypeSafe account, TypeSafe bills you, and the call costs no credits here. If TypeSafe refuses the key, the call fails with that message instead of quietly running on ours.

Make a call

Your state, your questions. The state can be a string, an object or an array, the options are whatever you define, and the answers come back with a probability on each. Jev API access here is the whole surface — there is no smaller version of the API you have to graduate out of.

curl -X POST https://jev-agent.com/api/v1/systemone \
  -H "Authorization: Bearer jv_live_…" \
  -H "content-type: application/json" \
  -d '{
    "state": {
      "application": { "id": "APP-9912", "stage": "underwriting",
                       "ltv": 0.82, "flags": ["thin_file"] },
      "note": "Applicant self-employed 14 months."
    },
    "questions": {
      "decision": {
        "type": "choice",
        "instructions": "Route this application.",
        "criteria": {
          "auto_approve":  "clean file, meets all policy",
          "manual_review": "needs a human underwriter",
          "decline":       "fails policy outright",
          "request_docs":  "missing documentation"
        }
      }
    }
  }'

The real answer to this request, from api.typesafe.ai on 2026-10-11 in 513 ms; this endpoint returns the same plus a quota object:

{
  "model": "jev-1.13.0",
  "answers": {
    "decision": { "type": "choice", "choice": "manual_review", "confidence": 0.75,
                  "probabilities": { "manual_review": 0.81, "request_docs": 0.17,
                                     "decline": 0.02, "auto_approve": 0 } }
  },
  "usage": { "input_tokens": 413, "output_tokens": 51 }
}

Nothing above is a fixed category. Underwriting is the example because it is not one of our rulesets — swap the state and the criteria for your own domain and it works the same way.

The rulesets: skip writing questions

Writing good criteria is most of the work — the option descriptions are the entire prompt surface. If one of these eight already asks what you need, /api/v1/classify asks it for you: send text and a ruleset name, up to 20 items per request (50 with credits). A batch is billed on its input tokens like any other call. The catalogue is readable without a key at GET /api/v1/classify, and a full request and response is in the docs.

• support-ticket-triage3q
• llm-model-routing1q
• agent-tool-selection1q
• content-moderation3q
• phishing-detection5q
• rag-reranking1q
• agent-output-guardrails4q
• lead-scoring3q

Every ruleset publishes the exact call it makes. GET /api/v1/rulesets/<id>, no key needed, returns the literal {model, state, questions} body we send to api.typesafe.ai on your behalf:

curl -s https://jev-agent.com/api/v1/rulesets/support-ticket-triage | jq .official

Take that body and your own TypeSafe key, and you never need to call us again.

How this Jev API access differs from the official API

POST /api/v1/systemone is POST https://api.typesafe.ai/v1/systemone with a different host and a different bearer token. Same request fields, same answer shapes. When your own early-access key arrives, change those two things and delete nothing else.

Not in what it accepts. The only ceilings are upstream's, checked before the call: 255 options per Choice and 10 levels per Score. A long state is priced per input token, not refused, up to Jev's own token budget.

• The versioned model id comes back. Every response carries the model that actually answered — jev-1.13.0 today, not the alias. An alias moves when a release ships, so a confidence threshold tuned against one set of weights can drift with nothing in your code having changed.
• One extra key. The response carries a quota object. Delete it and what is left is exactly what api.typesafe.ai sends.

The full contract, including every validation message, is readable without a key at GET /api/v1/systemone.

Limits and honesty

• 5 credits a month, free. The counter resets on the calendar month; past that there are one-off credit packs on Plans, nothing that renews.
• The key is shown once. Only its hash is stored, so a leaked database does not hand anyone a working set — and nobody here can read your key back to you.
• You can kill a leaked key yourself. DELETE /api/keys with it as the bearer token stops it immediately.
• Rotating does not buy another month. The counter follows your address, not your key.
• No uptime promise. This runs on one site's budget. Do not put it on a path where an outage matters.
• Your text is not stored. It is forwarded to the model and the response is returned. What we keep is usage — credits, tokens, timing — never the content.