Using the Management Client

The Management API client provides access to all Auth0 Management API endpoints for managing your Auth0 tenant programmatically.

Initializing the Client

The Management API client supports multiple authentication methods. Choose the one that best fits your use case.

Client Credentials
Custom Audience
Private Key JWT
Static Token
Custom Token Source

The most common authentication method using a client ID and secret:

import (
    "context"
    "github.com/auth0/go-auth0/v2/management/client"
    "github.com/auth0/go-auth0/v2/management/option"
)

mgmt, err := client.New(
    "your-tenant.auth0.com",
    option.WithClientCredentials(
        context.Background(),
        "YOUR_CLIENT_ID",
        "YOUR_CLIENT_SECRET",
    ),
)
if err != nil {
    log.Fatalf("Error creating management client: %v", err)
}

Use a custom audience for API access:

mgmt, err := client.New(
    "your-tenant.auth0.com",
    option.WithClientCredentialsAndAudience(
        context.Background(),
        "YOUR_CLIENT_ID",
        "YOUR_CLIENT_SECRET",
        "https://custom-api.example.com",
    ),
)

For enhanced security using Private Key JWT:

mgmt, err := client.New(
    "your-tenant.auth0.com",
    option.WithClientCredentialsPrivateKeyJwt(
        context.Background(),
        "YOUR_CLIENT_ID",
        privateKeyPEM, // PEM-encoded private key
        "RS256",
    ),
)

Use a pre-acquired access token:

mgmt, err := client.New(
    "your-tenant.auth0.com",
    option.WithToken("YOUR_ACCESS_TOKEN"),
)

For advanced token management with caching:

import "golang.org/x/oauth2"

// Create a custom token source
myTokenSource := oauth2.StaticTokenSource(&oauth2.Token{
    AccessToken: "YOUR_TOKEN",
})

// Wrap with ReuseTokenSource for automatic caching
mgmt, err := client.New(
    "your-tenant.auth0.com",
    option.WithTokenSource(
        oauth2.ReuseTokenSource(nil, myTokenSource),
    ),
)

Authentication Options are Mutually ExclusiveThe authentication options (WithClientCredentials, WithClientCredentialsAndAudience, WithClientCredentialsPrivateKeyJwt, WithClientCredentialsPrivateKeyJwtAndAudience, and WithTokenSource) are mutually exclusive. If multiple are provided, the last one takes effect.

Resource Management

The Management API client provides access to all Auth0 resources through dedicated service objects.

Available Services

The management client exposes the following services:

mgmt.Users              // User management
mgmt.Clients            // Application/client management
mgmt.Connections        // Connection management
mgmt.ResourceServers    // API (resource server) management
mgmt.Roles              // Role management
mgmt.Organizations      // Organization management

Making API Requests

All API operations follow a consistent pattern:

Create Request Parameters

Define the parameters for your request:

listRequest := &management.ListUsersRequestParameters{
    Search:  management.String("email:\"*@example.com\""),
    Sort:    management.String("created_at:1"),
    PerPage: management.Int(50),
}

Execute the Request

Call the appropriate method with context and parameters:

ctx := context.Background()
usersPage, err := mgmt.Users.List(ctx, listRequest)
if err != nil {
    return err
}

Process the Response

Handle the returned data:

for _, user := range usersPage.Results {
    fmt.Printf("User: %s (%s)\n",
        *user.GetEmail(),
        *user.GetUserID(),
    )
}

Helper Functions

The SDK provides helper functions for creating pointer values:

import "github.com/auth0/go-auth0/v2/management"

// Create request with helper functions
listRequest := &management.ListClientsRequestParameters{
    AppType:       management.String("spa"),
    Page:          management.Int(0),
    PerPage:       management.Int(25),
    Fields:        management.String("client_id,name,app_type"),
    IncludeFields: management.Bool(true),
}

// These helpers create *string, *int, and *bool values
// management.String("value") returns *string
// management.Int(42) returns *int
// management.Bool(true) returns *bool

Safe Getters

The SDK provides safe getter methods to avoid nil pointer panics:

user, err := mgmt.Users.Read(ctx, userID)
if err != nil {
    return err
}

// Safe getters return zero values if the field is nil
email := user.GetEmail()          // Returns "" if Email is nil
verified := user.GetEmailVerified() // Returns false if EmailVerified is nil
createdAt := user.GetCreatedAt()   // Returns "" if CreatedAt is nil

// You can safely use these in conditions
if email != "" {
    fmt.Printf("Email: %s\n", email)
}

Pagination

The SDK uses a Page type for pagination with built-in iterator support.

Using Iterator (Recommended)
Manual Pagination
Checkpoint Pagination

The easiest way to paginate through results:

listRequest := &management.ListUsersRequestParameters{
    PerPage: management.Int(50),
}

usersPage, err := mgmt.Users.List(ctx, listRequest)
if err != nil {
    return err
}

// Automatically handles pagination
iterator := usersPage.Iterator()
for iterator.Next(ctx) {
    user := iterator.Current()
    fmt.Printf("User: %s\n", *user.GetEmail())
}

if iterator.Err() != nil {
    return iterator.Err()
}

For more control over pagination:

import (
    "errors"
    "github.com/auth0/go-auth0/v2/management/core"
)

page := 0
for {
    listRequest := &management.ListClientsRequestParameters{
        Page:    management.Int(page),
        PerPage: management.Int(25),
    }

    clientsPage, err := mgmt.Clients.List(ctx, listRequest)
    if err != nil {
        return err
    }

    // Process current page
    for _, client := range clientsPage.Results {
        fmt.Printf("Client: %s\n", *client.GetName())
    }

    // Try to get next page
    nextPage, err := clientsPage.GetNextPage(ctx)
    if err != nil {
        if errors.Is(err, core.ErrNoPages) {
            break // No more pages
        }
        return err
    }

    clientsPage = nextPage
    page++
}

For logs and organizations that use checkpoint-based pagination:

logListRequest := &management.ListLogsRequestParameters{
    Take: management.Int(100),
}

logsPage, err := mgmt.Logs.List(ctx, logListRequest)
if err != nil {
    return err
}

// Iterator automatically handles checkpoint pagination
iterator := logsPage.Iterator()
for iterator.Next(ctx) {
    log := iterator.Current()
    fmt.Printf("Log: %s - %s\n",
        *log.GetID(),
        *log.GetType(),
    )
}

if iterator.Err() != nil {
    return iterator.Err()
}

Error Handling

Handle errors appropriately in your applications:

import "errors"

// Basic error handling
users, err := mgmt.Users.List(ctx, listRequest)
if err != nil {
    fmt.Printf("Error listing users: %v\n", err)
    return err
}

// Handle pagination errors
for {
    nextPage, err := usersPage.GetNextPage(ctx)
    if err != nil {
        if errors.Is(err, core.ErrNoPages) {
            // Expected end of pagination
            break
        }
        // Actual error occurred
        return fmt.Errorf("error getting next page: %w", err)
    }
    usersPage = nextPage
}

Complete Example

Here’s a complete example demonstrating common management operations:

package main

import (
    "context"
    "fmt"
    "log"

    "github.com/auth0/go-auth0/v2/management"
    "github.com/auth0/go-auth0/v2/management/client"
    "github.com/auth0/go-auth0/v2/management/option"
)

func main() {
    // Initialize management client
    mgmt, err := client.New(
        "your-tenant.auth0.com",
        option.WithClientCredentials(
            context.Background(),
            "YOUR_CLIENT_ID",
            "YOUR_CLIENT_SECRET",
        ),
    )
    if err != nil {
        log.Fatalf("Error creating management client: %v", err)
    }

    ctx := context.Background()

    // Create a new user
    createUserRequest := &management.CreateUserRequestContent{
        Email:      "[email protected]",
        Connection: "Username-Password-Authentication",
        Password:   management.String("TempPassword123!"),
        UserMetadata: map[string]interface{}{
            "plan": "premium",
        },
    }

    user, err := mgmt.Users.Create(ctx, createUserRequest)
    if err != nil {
        log.Fatalf("Error creating user: %v", err)
    }

    fmt.Printf("Created user: %s (ID: %s)\n",
        *user.GetEmail(),
        *user.GetUserID(),
    )

    // List all SPA clients
    listRequest := &management.ListClientsRequestParameters{
        AppType: management.String("spa"),
        PerPage: management.Int(10),
    }

    clientsPage, err := mgmt.Clients.List(ctx, listRequest)
    if err != nil {
        log.Fatalf("Error listing clients: %v", err)
    }

    fmt.Println("\nSPA Clients:")
    iterator := clientsPage.Iterator()
    for iterator.Next(ctx) {
        client := iterator.Current()
        fmt.Printf("- %s (%s)\n",
            *client.GetName(),
            *client.GetClientID(),
        )
    }

    if iterator.Err() != nil {
        log.Fatalf("Error iterating clients: %v", iterator.Err())
    }

    // Update the user
    updateRequest := &management.UpdateUserRequestContent{
        UserMetadata: map[string]interface{}{
            "plan":         "premium",
            "last_updated": "2024-01-01",
        },
    }

    updatedUser, err := mgmt.Users.Update(
        ctx,
        *user.GetUserID(),
        updateRequest,
    )
    if err != nil {
        log.Fatalf("Error updating user: %v", err)
    }

    fmt.Printf("\nUpdated user metadata: %v\n",
        updatedUser.UserMetadata,
    )
}

Next Steps

User Management

Learn how to manage users

Client Management

Learn how to manage applications

Connection Management

Learn how to manage connections

Request Options

Customize requests with advanced options

Get Started

Core Concepts

Guides

Advanced

Migration

Using the Management Client

Initializing the Client

Resource Management

Available Services

Making API Requests

Helper Functions

Safe Getters

Error Handling

Complete Example

Next Steps

User Management

Client Management

Connection Management

Request Options

Build docs developers (and LLMs) love

Get Started

Core Concepts

Guides

Advanced

Migration

​Initializing the Client

​Resource Management

​Available Services

​Making API Requests

​Helper Functions

​Safe Getters

​Pagination

​Error Handling

​Complete Example

​Next Steps

User Management

Client Management

Connection Management

Request Options

Build docs developers (and LLMs) love

Initializing the Client

Resource Management

Available Services

Making API Requests

Helper Functions

Safe Getters

Pagination

Error Handling

Complete Example

Next Steps