Rust SDK

The passkeybase crate provides an async Rust client for the PasskeyBase Management API. Manage users, credentials, apps, roles, and enrollment tokens from your Rust backend.

Installation

Add via Cargo:

Terminal

cargo add passkeybase

Quick Start

Initialize the client with your Management API key and tenant domain, then make your first API call.

main.rs

use passkeybase::Client;

#[tokio::main]
async fn main() -> Result<(), passkeybase::Error> {
    let client = Client::builder()
        .api_key("YOUR_MANAGEMENT_API_KEY")
        .domain("myapp.auth.ing")
        .build()?;

    // List all users
    let users = client.users().list(None).await?;
    for user in &users.data {
        println!("{}: {}", user.id, user.display_name);
    }

    Ok(())
}

User Management

Create User

Create a user

use passkeybase::users::CreateUserParams;

let user = client.users().create(CreateUserParams {
    external_id: "user_123".into(),
    display_name: "Jane Doe".into(),
}).await?;
println!("Created user: {}", user.id);

List Users

List users with pagination

use passkeybase::ListParams;

// List with pagination
let users = client.users().list(Some(ListParams {
    page: 1,
    per_page: 20,
})).await?;

for user in &users.data {
    println!("{}: {}", user.id, user.display_name);
}

println!("Total: {}", users.pagination.total);

Get User

Get a user by ID

let user = client.users().get("usr_abc123").await?;
println!("Name: {}", user.display_name);
println!("Passkeys: {}", user.passkey_count);
println!("Last login: {:?}", user.last_login_at);

Update User

Update a user

use passkeybase::users::UpdateUserParams;

let user = client.users().update("usr_abc123", UpdateUserParams {
    display_name: Some("Jane Smith".into()),
}).await?;
println!("Updated: {}", user.display_name);

Delete User

Deletes a user and all their associated passkeys.

Delete a user

client.users().delete("usr_abc123").await?;

Block / Unblock User

Block and unblock

// Block a user (prevents authentication)
client.users().block("usr_abc123").await?;

// Unblock a user
client.users().unblock("usr_abc123").await?;

Credential Management

List Credentials

List all passkey credentials for a specific user.

List credentials

let credentials = client.credentials().list("usr_abc123").await?;
for cred in &credentials.data {
    println!("{}: {} ({})", cred.id, cred.device_name, cred.authenticator_type);
}

Delete Credential

Revoke a specific passkey credential.

Delete a credential

client.credentials().delete("usr_abc123", "pk_xyz789").await?;

Client / App Management

Create App

Create an OAuth app

use passkeybase::apps::CreateAppParams;

let app = client.apps().create(CreateAppParams {
    name: "My Mobile App".into(),
    redirect_uris: vec!["myapp://callback".into()],
}).await?;
println!("Client ID: {}", app.id);

Rotate Secret

Rotate client secret

let secret = client.apps().rotate_secret("pk_live_abc123").await?;
println!("New secret: {}", secret.client_secret);

Role Management

Create Role

Create a role

use passkeybase::roles::CreateRoleParams;

let role = client.roles().create(CreateRoleParams {
    name: "admin".into(),
    description: "Administrator role".into(),
}).await?;
println!("Role ID: {}", role.id);

Assign Users

Assign users to a role

client.roles().assign_user("role_abc123", "usr_abc123").await?;

// List users in a role
let users = client.roles().list_users("role_abc123").await?;
for user in &users.data {
    println!("{}: {}", user.id, user.display_name);
}

Enrollment Tokens

Generate a one-time token for enrolling a passkey for an existing user. See the Enrollment guide for the full flow.

Create enrollment token

use passkeybase::enrollment::CreateEnrollmentTokenParams;

let token = client.enrollment_tokens().create(CreateEnrollmentTokenParams {
    external_id: "user_123".into(),
    display_name: "Jane Doe".into(),
    expires_in: Some(3600),
}).await?;
println!("Token: {}", token.token);
println!("Expires: {}", token.expires_at);

// Return this token to your frontend for passkey enrollment

Error Handling

API errors are returned as passkeybase::Error enum variants. Use pattern matching to handle different error types.

Error handling

use passkeybase::{Client, Error};

let client = Client::builder()
    .api_key("YOUR_MANAGEMENT_API_KEY")
    .domain("myapp.auth.ing")
    .build()?;

match client.users().get("usr_nonexistent").await {
    Ok(user) => println!("Found: {}", user.display_name),
    Err(Error::Api { error, message, status }) => {
        println!("Error: {error}");     // "not_found"
        println!("Message: {message}"); // "User not found"
        println!("Status: {status}");   // 404
    }
    Err(Error::Network(e)) => {
        println!("Network error: {e}");
    }
    Err(e) => {
        println!("Other error: {e}");
    }
}

Configuration Options

Configuration

use std::time::Duration;

let client = Client::builder()
    .api_key("YOUR_MANAGEMENT_API_KEY")       // Required. Management API key.
    .domain("myapp.auth.ing")                 // Required. Your tenant domain.
    .timeout(Duration::from_secs(30))         // Optional. Request timeout. Default: 10s.
    .max_retries(3)                           // Optional. Max retry attempts. Default: 2.
    .base_url("https://custom.url")           // Optional. Override API base URL.
    .build()?;

Option	Type	Required	Description
`api_key`	&str	Yes	Your Management API key from the dashboard.
`domain`	&str	Yes	Your tenant domain (e.g., myapp.auth.ing).
`timeout`	Duration	No	Request timeout. Default: 10s.
`max_retries`	u32	No	Maximum retry attempts. Default: 2.
`base_url`	&str	No	Override the API base URL.