Skip to main content
KeyAuth authenticates requests using Unkey API keys. It is the only authentication policy the engine executes today; JWTAuth is defined in the schema but not yet active.

Fields

key_space_ids
string[]
List of keyspace IDs the key must belong to. If the key belongs to a keyspace not in this list, authentication fails with Frontline.Auth.InvalidKey.
locations
KeyLocation[]
Ordered list of locations to extract the API key from. Frontline tries each location in order and uses the first non-empty key. If omitted, defaults to extracting a Bearer token from the Authorization header.
permission_query
string
Optional RBAC query evaluated against the key’s permissions. If the key does not satisfy the query, authentication fails with Frontline.Auth.InsufficientPermissions.
ratelimits
KeyRatelimit[]
Optional list of rate limits to enforce on the verified key, mirroring the ratelimits field of the verifyKey API. Each entry references a rate limit by name. This is in addition to any auto-applied limits on the key or its identity, which are always enforced. Each entry may optionally override the limit, duration (milliseconds), and cost. Supplying both limit and duration defines an inline limit that does not need to exist on the key. If a named limit does not exist and no inline limit/duration is provided, the request is rejected.

Examples

Key extraction

Frontline supports three key extraction locations: When multiple locations are configured, Frontline tries each in order and uses the first non-empty result.

Verification flow

  1. Extract the key from the request using configured locations.
  2. Hash the key using SHA-256.
  3. Look up the hash in the key cache (fresh: 10s, stale: 10min, max: 100k entries).
  4. Validate key status. Keys that are not found, disabled, expired, or belong to a disabled workspace are rejected.
  5. Verify the key belongs to one of the configured key_space_ids.
  6. Parse the permission query (if configured) and build verify options, including any configured key ratelimits.
  7. Call verifier.Verify() with 1 credit deduction per request. Auto-applied key/identity limits and any policy-configured ratelimits are enforced here, using the same path as the verifyKey API.
  8. Write rate limit headers (regardless of success or failure).
  9. Check post-verification status (rate limit, usage exceeded, permissions).
  10. Build and return the principal on success.

Response headers

KeyAuth writes rate limit headers on every response, including rejected requests:

Error responses