PasskeyBase
FeaturesCase studiesPricingDocsLive samplesDashboard
Get Started

Go SDK

The passkeybase-go package provides a Go client for the PasskeyBase Management API. Manage users, credentials, apps, roles, and enrollment tokens from your Go backend.

Installation

Install via go get:

Terminal
go get github.com/passkeybase/passkeybase-go

Quick Start

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

main.go
package main

import (
	"context"
	"fmt"
	"log"

	"github.com/passkeybase/passkeybase-go"
)

func main() {
	client := passkeybase.NewClient(
		"YOUR_MANAGEMENT_API_KEY",
		passkeybase.WithDomain("myapp.auth.ing"),
	)

	// List all users
	ctx := context.Background()
	users, err := client.Users.List(ctx, nil)
	if err != nil {
		log.Fatal(err)
	}

	for _, user := range users.Data {
		fmt.Printf("%s: %s\n", user.ID, user.DisplayName)
	}
}

User Management

Create User

Create a user
user, err := client.Users.Create(ctx, &passkeybase.CreateUserParams{
	ExternalID:  "user_123",
	DisplayName: "Jane Doe",
})
if err != nil {
	log.Fatal(err)
}
fmt.Printf("Created user: %s\n", user.ID)

List Users

List users with pagination
// List with pagination
users, err := client.Users.List(ctx, &passkeybase.ListParams{
	Page:    1,
	PerPage: 20,
})
if err != nil {
	log.Fatal(err)
}

for _, user := range users.Data {
	fmt.Printf("%s: %s\n", user.ID, user.DisplayName)
}

fmt.Printf("Total: %d\n", users.Pagination.Total)

Get User

Get a user by ID
user, err := client.Users.Get(ctx, "usr_abc123")
if err != nil {
	log.Fatal(err)
}
fmt.Printf("Name: %s\n", user.DisplayName)
fmt.Printf("Passkeys: %d\n", user.PasskeyCount)
fmt.Printf("Last login: %s\n", user.LastLoginAt)

Update User

Update a user
user, err := client.Users.Update(ctx, "usr_abc123", &passkeybase.UpdateUserParams{
	DisplayName: "Jane Smith",
})
if err != nil {
	log.Fatal(err)
}
fmt.Printf("Updated: %s\n", user.DisplayName)

Delete User

Deletes a user and all their associated passkeys.

Delete a user
err := client.Users.Delete(ctx, "usr_abc123")
if err != nil {
	log.Fatal(err)
}

Block / Unblock User

Block and unblock
// Block a user (prevents authentication)
err := client.Users.Block(ctx, "usr_abc123")
if err != nil {
	log.Fatal(err)
}

// Unblock a user
err = client.Users.Unblock(ctx, "usr_abc123")
if err != nil {
	log.Fatal(err)
}

Credential Management

List Credentials

List all passkey credentials for a specific user.

List credentials
credentials, err := client.Credentials.List(ctx, "usr_abc123")
if err != nil {
	log.Fatal(err)
}

for _, cred := range credentials.Data {
	fmt.Printf("%s: %s (%s)\n", cred.ID, cred.DeviceName, cred.AuthenticatorType)
}

Delete Credential

Revoke a specific passkey credential.

Delete a credential
err := client.Credentials.Delete(ctx, "usr_abc123", "pk_xyz789")
if err != nil {
	log.Fatal(err)
}

Client / App Management

Create App

Create an OAuth app
app, err := client.Apps.Create(ctx, &passkeybase.CreateAppParams{
	Name:         "My Mobile App",
	RedirectURIs: []string{"myapp://callback"},
})
if err != nil {
	log.Fatal(err)
}
fmt.Printf("Client ID: %s\n", app.ID)

Rotate Secret

Rotate client secret
secret, err := client.Apps.RotateSecret(ctx, "pk_live_abc123")
if err != nil {
	log.Fatal(err)
}
fmt.Printf("New secret: %s\n", secret.ClientSecret)

Role Management

Create Role

Create a role
role, err := client.Roles.Create(ctx, &passkeybase.CreateRoleParams{
	Name:        "admin",
	Description: "Administrator role",
})
if err != nil {
	log.Fatal(err)
}
fmt.Printf("Role ID: %s\n", role.ID)

Assign Users

Assign users to a role
err := client.Roles.AssignUser(ctx, "role_abc123", "usr_abc123")
if err != nil {
	log.Fatal(err)
}

// List users in a role
users, err := client.Roles.ListUsers(ctx, "role_abc123")
if err != nil {
	log.Fatal(err)
}
for _, user := range users.Data {
	fmt.Printf("%s: %s\n", user.ID, user.DisplayName)
}

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
token, err := client.EnrollmentTokens.Create(ctx, &passkeybase.CreateEnrollmentTokenParams{
	ExternalID:  "user_123",
	DisplayName: "Jane Doe",
	ExpiresIn:   3600,
})
if err != nil {
	log.Fatal(err)
}
fmt.Printf("Token: %s\n", token.Token)
fmt.Printf("Expires: %s\n", token.ExpiresAt)

// Return this token to your frontend for passkey enrollment

Error Handling

API errors are returned as *passkeybase.Error. Use errors.As to check for typed API errors.

Error handling
import "errors"

user, err := client.Users.Get(ctx, "usr_nonexistent")
if err != nil {
	var apiErr *passkeybase.Error
	if errors.As(err, &apiErr) {
		fmt.Printf("Error: %s\n", apiErr.ErrorCode)  // "not_found"
		fmt.Printf("Message: %s\n", apiErr.Message)   // "User not found"
		fmt.Printf("Status: %d\n", apiErr.Status)     // 404
	} else {
		fmt.Printf("Network error: %v\n", err)
	}
}

Configuration Options

Configuration
client := passkeybase.NewClient(
	"YOUR_MANAGEMENT_API_KEY",                        // Required. Management API key.
	passkeybase.WithDomain("myapp.auth.ing"),         // Required. Your tenant domain.
	passkeybase.WithTimeout(30 * time.Second),        // Optional. Request timeout. Default: 10s.
	passkeybase.WithMaxRetries(3),                    // Optional. Max retry attempts. Default: 2.
	passkeybase.WithBaseURL("https://custom.url"),    // Optional. Override API base URL.
	passkeybase.WithHTTPClient(customHTTPClient),     // Optional. Custom http.Client.
)
OptionTypeRequiredDescription
apiKeystringYesYour Management API key from the dashboard.
WithDomainstringYesYour tenant domain (e.g., myapp.auth.ing).
WithTimeouttime.DurationNoRequest timeout. Default: 10s.
WithMaxRetriesintNoMaximum retry attempts. Default: 2.
WithBaseURLstringNoOverride the API base URL.
WithHTTPClient*http.ClientNoCustom HTTP client.