From zero to first integration in 5–30 minutes.

Choose your integration goal. Follow the guided walkthrough. Read the verified code sample. Connect to your first identity, authority or evidence layer. Every path is tested, documented, and ready to scale.

Find a quickstart

API reference

Choose your path

Filter by your integration goal, actor type, and preferred language. Each quickstart includes prerequisites, verified code samples, error scenarios, and next steps.

Goal

Actor

Language

Level

Add SSO to your app

VERIFIED5 min

Integrate OAuth 2.0 / OIDC. Verify user identity with your existing IdP (Okta, Azure AD, Keycloak). Layer Zoiko iD on top.

ACTORHuman user

LANGUAGEJavaScript, Python, Go

Start guide

Issue an agent credential

VERIFIED8 min

Enroll a service, AI agent, or non-human principal. Generate API keys. Bind identity to your bot, workflow, or automation.

ACTORAI Agent / Service

LANGUAGEAll SDKs

Start guide

Create a delegation mandate

VERIFIED12 min

Grant time-limited, scoped on-behalf-of access. Define scope, purpose, and expiry. Revoke instantly when needed.

ACTORThird- party user

LANGUAGEPython, JavaScript

Start guide

Stream identity events

VERIFIED10 min

Subscribe to credential issued, revoked, mandate expired events. Build custom audit, compliance and observability workflows.

PATTERNEvent- driven

LANGUAGEAll languages

Start guide

Check mandate status

VERIFIED6 min

Query delegation status. Verify actor has valid mandate. Evaluate policy. Make access control decisions at request time.

PATTERNPolicy check

LANGUAGEGo, Python, Java

Start guide

Query evidence trail

CONCEPTUAL15 min

Search audit logs. Filter by actor, action, time range. Export compliance evidence. Build compliance dashboards.

PATTERNQuery / Search

LANGUAGEPython, JavaScript

Start guide

Common code patterns

Verify actor identity

Check if a principal's credential is valid and not revoked.

Conceptual example

// Verify credential validity
credential = zoiko.credentials.get(actor_id)
if credential.is_valid():
    if credential.is_revoked():
        return DENIED
    return ALLOWED
else:
    return EXPIRED

Evaluate mandate scope

Check if an action fits the delegated mandate scope.

Conceptual example

// Check if action is within mandate
mandate = zoiko.mandates.get(delegation_id)
if mandate.resource == requested_resource:
    if requested_action in mandate.allowed_actions:
        if mandate.is_within_time_bounds():
            return ALLOWED
return DENIED

Handle revocation event

Respond to mandate.revoked webhook.

Conceptual example

// Webhook handler
def on_mandate_revoked(event):
    delegation_id = event.mandate_id
    affected_actor = event.actor_id
    
    # Invalidate cached state
    cache.delete(f"mandate:{delegation_id}")
    
    # Alert downstream systems
    notify_services(
        action="revoke_access",
        actor=affected_actor,
        reason=event.reason
    )

Understand quickstart status

VERIFIED

Code samples tested and working. Safe to copy and run. Maintained with every release.

CONCEPTUAL

Pseudocode or architecture guide. Illustrates patterns. Not ready to run as-is.

PLANNED

Coming soon. Sign up to be notified when this path launches.

UNSUPPORTED

Not in scope for now. Talk to our team for a custom solution.

Before you start

Zoiko iD sandbox account

Request sandbox access. We'll provision an isolated test environment and give you API keys.

SDK or CLI installed

Install the SDK for your language. Or use the CLI tool. Both are optional but make things faster.

API reference open

Have our API Reference handy. Quickstarts point to specific endpoints. Reference has all the details.

Error scenarios and recovery

Why it happens: Actor's delegation was withdrawn by the delegator, or time boundary was reached, or policy was updated.

What to do:

Check mandate status: is it revoked or expired?
If expired, request a new mandate with extended date.
If revoked, contact the delegator to understand why.
Implement exponential backoff before retrying.

Safe retry pattern

def retry_with_backoff(fn, max_retries=3):
    backoff_ms = 100
    for attempt in range(max_retries):
        try:
            return fn()
        except ForbiddenError as e:
            if attempt < max_retries - 1:
                time.sleep(backoff_ms / 1000)
                backoff_ms *= 2
            else:
                # Final attempt failed; escalate
                log_and_alert(e)