C++ SDK

The passkeybase library provides a C++ client for the PasskeyBase Management API. Manage users, credentials, apps, roles, and enrollment tokens from your C++ backend.

Installation

Add via CMake FetchContent:

CMakeLists.txt

# CMakeLists.txt
include(FetchContent)

FetchContent_Declare(
  passkeybase
  GIT_REPOSITORY https://github.com/passkeybase/passkeybase-cpp.git
  GIT_TAG v1.0.0
)

FetchContent_MakeAvailable(passkeybase)

target_link_libraries(your_app PRIVATE passkeybase::passkeybase)

Quick Start

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

main.cpp

#include <passkeybase/client.h>
#include <iostream>

int main() {
    auto client = passkeybase::Client::builder()
        .api_key("YOUR_MANAGEMENT_API_KEY")
        .domain("myapp.auth.ing")
        .build();

    // List all users
    auto users = client.users().list();
    for (const auto& user : users.data) {
        std::cout << user.id << ": " << user.display_name << std::endl;
    }

    return 0;
}

User Management

Create User

Create a user

passkeybase::CreateUserParams params;
params.external_id = "user_123";
params.display_name = "Jane Doe";

auto user = client.users().create(params);
std::cout << "Created user: " << user.id << std::endl;

List Users

List users with pagination

// List with pagination
passkeybase::ListParams params;
params.page = 1;
params.per_page = 20;

auto users = client.users().list(params);
for (const auto& user : users.data) {
    std::cout << user.id << ": " << user.display_name << std::endl;
}

std::cout << "Total: " << users.pagination.total << std::endl;

Get User

Get a user by ID

auto user = client.users().get("usr_abc123");
std::cout << "Name: " << user.display_name << std::endl;
std::cout << "Passkeys: " << user.passkey_count << std::endl;
std::cout << "Last login: " << user.last_login_at << std::endl;

Update User

Update a user

passkeybase::UpdateUserParams params;
params.display_name = "Jane Smith";

auto user = client.users().update("usr_abc123", params);
std::cout << "Updated: " << user.display_name << std::endl;

Delete User

Deletes a user and all their associated passkeys.

Delete a user

client.users().remove("usr_abc123");

Block / Unblock User

Block and unblock

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

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

Credential Management

List Credentials

List all passkey credentials for a specific user.

List credentials

auto credentials = client.credentials().list("usr_abc123");
for (const auto& cred : credentials.data) {
    std::cout << cred.id << ": " << cred.device_name
              << " (" << cred.authenticator_type << ")" << std::endl;
}

Delete Credential

Revoke a specific passkey credential.

Delete a credential

client.credentials().remove("usr_abc123", "pk_xyz789");

Client / App Management

Create App

Create an OAuth app

passkeybase::CreateAppParams params;
params.name = "My Mobile App";
params.redirect_uris = {"myapp://callback"};

auto app = client.apps().create(params);
std::cout << "Client ID: " << app.id << std::endl;

Rotate Secret

Rotate client secret

auto secret = client.apps().rotate_secret("pk_live_abc123");
std::cout << "New secret: " << secret.client_secret << std::endl;

Role Management

Create Role

Create a role

passkeybase::CreateRoleParams params;
params.name = "admin";
params.description = "Administrator role";

auto role = client.roles().create(params);
std::cout << "Role ID: " << role.id << std::endl;

Assign Users

Assign users to a role

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

// List users in a role
auto users = client.roles().list_users("role_abc123");
for (const auto& user : users.data) {
    std::cout << user.id << ": " << user.display_name << std::endl;
}

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

passkeybase::CreateEnrollmentTokenParams params;
params.external_id = "user_123";
params.display_name = "Jane Doe";
params.expires_in = 3600;

auto token = client.enrollment_tokens().create(params);
std::cout << "Token: " << token.token << std::endl;
std::cout << "Expires: " << token.expires_at << std::endl;

// Return this token to your frontend for passkey enrollment

Error Handling

API errors throw passkeybase::ApiError exceptions. Network errors throw passkeybase::NetworkError.

Error handling

#include <passkeybase/client.h>
#include <passkeybase/error.h>
#include <iostream>

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

try {
    auto user = client.users().get("usr_nonexistent");
} catch (const passkeybase::ApiError& e) {
    std::cout << "Error: " << e.error() << std::endl;      // "not_found"
    std::cout << "Message: " << e.message() << std::endl;   // "User not found"
    std::cout << "Status: " << e.status() << std::endl;     // 404
} catch (const passkeybase::NetworkError& e) {
    std::cout << "Network error: " << e.what() << std::endl;
}

Configuration Options

Configuration

#include <chrono>

auto client = passkeybase::Client::builder()
    .api_key("YOUR_MANAGEMENT_API_KEY")                        // Required. Management API key.
    .domain("myapp.auth.ing")                                  // Required. Your tenant domain.
    .timeout(std::chrono::seconds(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`	std::string	Yes	Your Management API key from the dashboard.
`domain`	std::string	Yes	Your tenant domain (e.g., myapp.auth.ing).
`timeout`	std::chrono::duration	No	Request timeout. Default: 10s.
`max_retries`	int	No	Maximum retry attempts. Default: 2.
`base_url`	std::string	No	Override the API base URL.