Sign-up and API Key: get your TypeSafe key in 5 minutes

In the previous lesson you already learned what Jev is. This lesson gets the key into your hands: complete TypeSafe sign-up, go into the console to create a Jev API Key, store it in an environment variable, then verify it actually works with the official Playground — the whole thing takes 5 minutes without writing a single line of code.

What you'll be able to do after this lesson

• Complete TypeSafe sign-up and log into the TypeSafe console
• Create a Jev API Key on the console Keys page
• Store the Key in the environment variable TYPESAFE_API_KEY so the SDK reads it automatically
• Send one real request with the Playground to confirm the Key works
• Know where to check rate limits and what happens when you exceed them

Where you are right now

• You want to try Jev but don't know where to get a Key: the site, docs, and console have a pile of entry points, and you circled around forever without finding where to generate one
• You pasted the Key into your code and got it running once, then broke out in a cold sweat when you went to commit to git
• You've heard there are rate limits but don't know what your quota is or what happens if you exceed it

When to use this technique

When you need:

• One Jev API Key that can call api.typesafe.ai
• A way to verify whether a Key works without writing code

And you don't want to:

• Write the secret key in plaintext into your code or repository
• Plow through an entire API doc before getting your first request working

🎒 Preparation before starting

• Finish the previous lesson What is Jev, and know that Jev calls take the form of "state + question"
• A modern browser (sign-up, Key creation, and Playground verification all happen in the browser)
• A network that can reach console.typesafe.ai (the console) and api.typesafe.ai (the API)

Core idea

There is only one key, and only one entrance. All Jev calls — SDK, curl, Playground — go through the same API and authenticate with the same API Key. So the process is short: sign up → generate a Key in the console → store it in an environment variable → verify.

Why store it in an environment variable. The official guidance is explicit: after generating a Key, store it in an environment variable (such as TYPESAFE_API_KEY). Two benefits:

• The official SDK reads this variable automatically, so you never write a secret in your code
• If the Key never lands in a code file, it can't get committed along with git

TypeSafe console has three pages, each handling one thing.

Page	Address	What it's for
Keys	console.typesafe.ai/keys	Create API Keys
Playground	console.typesafe.ai/playground	Send real requests without code, verify Keys
Rate limits	console.typesafe.ai/rate-limits	Check your current organization's rate limits

One expectation to manage. Jev is currently in early access — the official site's exact words are "Try our first System One Model, Jev, in early access". The console interface may change across versions; this lesson only anchors to the addresses and processes stated in the official docs, and actual page details are subject to what you see.

⚠️ A note for users in mainland China

The official information sources contain no statements about mainland China network access or RMB payment, so this lesson offers no advice that cannot be verified; if you run into access or payment issues, follow the prompts on TypeSafe official pages.

Follow along

Step 1: complete TypeSafe sign-up and log into the console

Why: API Keys are only issued inside the TypeSafe console, so you need an account first.

Open console.typesafe.ai in your browser and follow the on-page prompts to sign up and log in.

What you should see: the console interface. This entry point is called "API console" in the site's navigation.

Step 2: create your Jev API Key on the Keys page

Why: the official quick start's exact words are "Get an API key from the TypeSafe console" — it refers to this Keys page.

Open console.typesafe.ai/keys and follow the on-page prompts to create a new Key.

You should see: a string of key text. Copy it to a local scratch space first—you'll need it in the next step.

• I copied the Key and did not paste it into any code file

Step 3: Store the Key in an environment variable TYPESAFE_API_KEY

Why: The official recommendation is to store the Key in an environment variable; the Python SDK reads TYPESAFE_API_KEY automatically, so the key never appears in code.

The official quick start syntax (Bash on macOS / Linux / Windows WSL):

export TYPESAFE_API_KEY="your-api-key"

Replace your-api-key with the key string you just copied.

You should see: no output after the command runs—export is silent on success.

💡 This command only applies to the current terminal

Variables set with export are gone once you close the terminal; you'll need to run it again in each new terminal. For a permanent setup, add it to your shell config file (e.g. ~/.bashrc)—this is general shell usage and is not covered in the TypeSafe official docs.

• I ran the export in my current terminal, with the variable name TYPESAFE_API_KEY

Step 4: Verify this Key with the Playground

Why: Confirm the Key works before writing any code—the Playground sends real requests right in the browser, with nothing to install.

1. Open console.typesafe.ai/playground and log in
2. Paste the official example ticket below into the state section:

Our API integration started returning 500 errors on every request about 20 minutes ago, and we can't process any customer orders until this is fixed.

3. Add the official example's Noul question:

{
  "urgency": {
    "type": "noul",
    "instructions": "Does this message express urgency?"
  }
}

You should see: a probability number between 0 and 1 returned. Getting a number means registration, the Key, and the network all work—this key is usable.

• I got a number between 0–1 in the Playground

Step 5: Take a look at your rate limits

Why: Jev's rate limits are calculated per organization, and requests that exceed them return 429; knowing where to check your quota up front gives you peace of mind when running batch jobs later.

Open console.typesafe.ai/rate-limits.

You should see: the current organization's limits, measured along two dimensions—tokens per second (tokens/s) and requests per second (requests/s).

Checkpoint ✅

• I can log in to the TypeSafe console, and I know the Key is created on the /keys page
• My Key is stored in the environment variable TYPESAFE_API_KEY and is not written into code
• I got a probability between 0–1 in the Playground using this Key
• I know rate limits are checked on the /rate-limits page, and exceeding them returns 429
• I know the official SDK reads TYPESAFE_API_KEY automatically

Pitfall warnings

❌ Hard-coding the Key into code or committing it to git

Once a key enters a repository, deleting the commit is too late—anyone who obtains the leaked Key can burn your quota. The right approach: store it in the environment variable TYPESAFE_API_KEY (the official recommendation), reference only TypeSafeClient(model="jev-latest") in code, and let the SDK read it itself.

❌ Requests return 401

401 = the Key is missing or invalid. Check three places in order: whether it was exported in the current terminal; whether the variable name is exactly TYPESAFE_API_KEY (all uppercase, no typos); and whether the copied Key carries any extra content. The official SDK strips leading and trailing whitespace from the Key (including newlines), but spaces, control characters, or non-ASCII characters inside the Key will cause outright rejection.

❌ Assuming the Key is broken when a request returns 429

429 = the rate limit was hit; it's not a Key problem. Limits are per organization (tokens/s + requests/s); check your quota on the /rate-limits page. The official SDK retries automatically by default (with progressively longer waits, honoring the retry-after response header); only direct HTTP API calls require handling it yourself. For higher quotas, go with a custom / enterprise plan—the officials provide an application form.

❌ Getting lost in the console

Just remember three pages: /keys to create a Key, /playground to test a Key, /rate-limits to check limits—typing the URL directly in the address bar is fastest.

Advanced tips (optional)

Configure this Key for your coding agent too. The official agent skill docs specifically mention: create an API Key, give your coding agent permission, and let it figure out the best way to use TypeSafe on its own through cheap test calls. The official docs even provide a ready-made prompt—"Run some experiments with the Key I exported to TYPESAFE_API_KEY, and propose changes based on the most promising results." Combined with the Developing with Claude Code lesson's TypeSafe skill, the agent can write code that calls Jev for you directly.

The relationship between the Key and pricing. This Key's calls to Jev are billed per token—input is billed, output is free. The complete table of rates, model versions, and context limits is on the Models and Pricing page.

Lesson summary

✅ TypeSafe Registration complete: you have a TypeSafe console account, and the Key was created on the /keys page.

✅ Key in place: stored in the environment variable TYPESAFE_API_KEY, read automatically by the official SDK, with zero keys in code.

✅ Key verified: a real probability was obtained in the Playground; you know to check rate limits at /rate-limits.

Key configuration fields recap:

Field	Recommended value	Description
TYPESAFE_API_KEY	Your Key (environment variable)	The officially recommended storage method; read automatically by the Python SDK
Key creation page	console.typesafe.ai/keys	Console Keys page
Playground	console.typesafe.ai/playground	Code-free Key verification and question testing
Rate limits page	console.typesafe.ai/rate-limits	Per organization: tokens/s + requests/s; exceeding limits returns 429

Next lesson preview

With your key in hand, the next lesson puts it to use: install the Python SDK and send your first request: get it running in 10 minutes.

You will learn:

• Install typesafe-sdk with venv + pip (Python 3.10+)
• Run the official three-question ticket example and get classification, scoring, and yes/no answers in one go
• Understand probabilities and confidence in the response
• Where to check first when installation fails or things won't run