Python guide

Protect a Python API with API keys, using the official SDK, unkey.py (version ). The examples use FastAPI, but the client calls are the same in Flask or Django. For a fuller FastAPI setup, see FastAPI authentication.

You need a root key with the permissions listed on this page. Create one in the dashboard under Settings > Root Keys, and pass it as Authorization: Bearer <root key>. See Permission reference for every permission.

Create a root key and a keyspace

In the dashboard, go to Settings > Root Keys and create a root key with api.*.create_api, api.*.create_key, and api.*.verify_key. Put it in your server’s UNKEY_ROOT_KEY environment variable. Never send it to a browser or mobile app.Then create a keyspace, which holds your keys. Use Keyspaces (APIs) in the dashboard, or apis.createApi:

create a keyspace

curl -X POST https://api.unkey.com/v2/apis.createApi \
  -H "Authorization: Bearer $UNKEY_ROOT_KEY" \
  -H "Content-Type: application/json" \
  -d '{ "name": "my-api" }'

Keep the data.apiId from the response. You need it to create keys. See Root keys for more on root keys.

Install the SDK

pip install unkey.py fastapi uvicorn

uv add unkey.py fastapi uvicorn

Create the client with Unkey(root_key=...). It works as a context manager, and every method has an _async version for asyncio.

Create a key for a user

Create a key from your backend when a user signs up or asks for one. externalId links the key to the user, so verification tells you who’s calling. meta comes back on every verification. You get data.key only once: show it to the user and store only data.keyId.

curl -X POST https://api.unkey.com/v2/keys.createKey \
  -H "Authorization: Bearer $UNKEY_ROOT_KEY" \
  -H "Content-Type: application/json" \
  -d '{ "apiId": "api_...", "prefix": "sk_live", "externalId": "user_123", "meta": { "plan": "free" } }'

import os

from unkey.py import Unkey

with Unkey(root_key=os.environ["UNKEY_ROOT_KEY"]) as unkey:
    created = unkey.keys.create_key(
        api_id=os.environ["UNKEY_API_ID"],
        prefix="sk_live",
        external_id="user_123",
        meta={"plan": "free"},
    )
    # created.data.key is the plaintext, created.data.key_id the handle you keep
    print(created.data.key_id)

Every field is described in Creating keys.

Verify the key in a dependency

The dependency reads the bearer token, calls keys.verify_key, and raises HTTPException with the right status when data.valid is false. If the call itself fails, it raises errors.UnkeyError, or an httpx error for a timeout or connection failure. Catch both and return 503, so callers can tell an outage from a rejected key.

main.py

import os

import httpx
from fastapi import Depends, FastAPI, HTTPException, Request
from unkey.py import Unkey, errors

app = FastAPI()
unkey = Unkey(root_key=os.environ["UNKEY_ROOT_KEY"])

STATUS = {
    "RATE_LIMITED": 429,
    "USAGE_EXCEEDED": 402,
    "FORBIDDEN": 403,
    "INSUFFICIENT_PERMISSIONS": 403,
}


def require_key(request: Request):
    auth = request.headers.get("authorization", "")
    if not auth.startswith("Bearer "):
        raise HTTPException(status_code=401, detail="missing API key")
    key = auth[len("Bearer "):]

    try:
        res = unkey.keys.verify_key(
            key=key,
            tags=[f"endpoint={request.url.path}", f"method={request.method}"],
        )
    except (errors.UnkeyError, httpx.HTTPError) as e:
        # The call failed (bad root key, throttle, outage), not the user's key.
        raise HTTPException(status_code=503, detail="authentication unavailable") from e

    if not res.data.valid:
        code = res.data.code
        raise HTTPException(status_code=STATUS.get(code, 401), detail=code)
    return res.data


@app.get("/items")
def list_items(verification=Depends(require_key)):
    owner = verification.identity.external_id if verification.identity else None
    return {"items": [], "owner": owner}

For an async app, create the client with async with Unkey(...) and call await unkey.keys.verify_key_async(key=key).

uvicorn main:app --port 3000
curl http://localhost:3000/items -H "Authorization: Bearer sk_live_..."

Handle the outcome codes

keys.verifyKey returns HTTP 200 for every outcome. Check data.valid, then data.code for the reason, and return the matching status from your API:

`data.code`	Meaning	Return
`VALID`	Every check passed.	continue
`NOT_FOUND`	No such key, or your root key may not verify this keyspace.	401
`DISABLED`	The key was disabled.	401
`EXPIRED`	The key’s expiry passed.	401
`FORBIDDEN`	Client IP not on the keyspace allow list, or the workspace is disabled.	403
`INSUFFICIENT_PERMISSIONS`	The `permissions` query was not satisfied.	403
`RATE_LIMITED`	A on the key or its identity was exceeded.	429
`USAGE_EXCEEDED`	The key has no credits left.	402 or 429

Remaining credits are in data.credits, and each checked rate limit is in data.ratelimits with remaining and reset. The call only fails with an HTTP error (which the SDKs throw) when the call itself is wrong, such as a bad root key or a malformed body. See Verifying keys for every field.

Next steps

Verifying keys

Every request field, the order of checks, and every response field.

Credits and refill

Meter usage per key and refill balances on a schedule.

Cookbook

Copy-ready recipes for rate limits, billing, and subscription tiers.

Get started

Framework guides

Keyspaces

Keys

Rate limiting

Identities

Authorization

Analytics

Audit logs

Developer portal

Security

Cookbook

Create a root key and a keyspace

Install the SDK

Create a key for a user

Verify the key in a dependency

Handle the outcome codes

Next steps

Verifying keys

Credits and refill

Cookbook