Auth0 Management API : automatiser la gestion des utilisateurs et connexions

L'API de management Auth0 permet d'automatiser la création d'utilisateurs, la gestion des rôles, l'export des logs et la configuration des connexions. Guide pratique avec exemples.

Par Auth0.Expert · 2025-03-15 · 11 min de lecture

Management API Automation DevOps

Auth0 Management API : guide d'automatisation

TL;DR

La Management API v2 d'Auth0 permet d'automatiser tout ce que vous faites dans le dashboard : créer des utilisateurs, assigner des rôles, exporter des logs, gérer les connexions. Indispensable pour les migrations et les workflows de provisioning.

---

Obtenir un token Management API

Ce code permet d’obtenir un jeton d’accès OAuth 2.0 en utilisant le flux machine-to-machine, indispensable pour s’authentifier auprès de la Management API d’Auth0.

# 1. Créer une Machine-to-Machine app dans Auth0
# 2. Autoriser cette app à accéder à l'API "Auth0 Management API"
# 3. Sélectionner les scopes nécessaires

curl -X POST https://YOUR_DOMAIN.auth0.com/oauth/token   -H "Content-Type: application/json"   -d '{
    "client_id": "MGMT_CLIENT_ID",
    "client_secret": "MGMT_CLIENT_SECRET",
    "audience": "https://YOUR_DOMAIN.auth0.com/api/v2/",
    "grant_type": "client_credentials"
  }'

---

Gestion des utilisateurs

Cette section détaille comment automatiser la gestion des utilisateurs dans Auth0 via API.

Créer un utilisateur

Cette requête crée un nouvel utilisateur dans la connexion de base de données Auth0 avec des métadonnées personnalisées.

curl -X POST "https://YOUR_DOMAIN.auth0.com/api/v2/users"   -H "Authorization: Bearer $MGMT_TOKEN"   -H "Content-Type: application/json"   -d '{
    "connection": "Username-Password-Authentication",
    "email": "[email protected]",
    "password": "Secure$Password123!",
    "given_name": "Jean",
    "family_name": "Dupont",
    "verify_email": true,
    "app_metadata": {
      "plan": "enterprise",
      "tenant_id": "acme-corp"
    }
  }'

Rechercher des utilisateurs

Ce script Python asynchrone cherche des utilisateurs dans Auth0 en filtrant avec la syntaxe Lucene, très utile en migration ou pour l’audit.

import httpx

async def search_users(mgmt_token: str, domain: str, query: str) -> list:
    """Recherche avec la syntaxe Lucene."""
    url = f"https://{domain}/api/v2/users"
    params = {
        "q": query,  # ex: "email:*@example.com" ou "app_metadata.tenant_id:acme-corp"
        "per_page": 100,
        "page": 0,
        "include_totals": True,
        "fields": "user_id,email,name,app_metadata,created_at",
    }
    headers = {"Authorization": f"Bearer {mgmt_token}"}

    async with httpx.AsyncClient() as client:
        resp = await client.get(url, params=params, headers=headers)
    return resp.json()

Ce code récupère la liste des utilisateurs répondant à une requête avancée (filtres, champs, pagination).

Mettre à jour app_metadata (sans mot de passe)

Cette commande met à jour la app_metadata d’un utilisateur sans toucher à son mot de passe.

curl -X PATCH "https://YOUR_DOMAIN.auth0.com/api/v2/users/USER_ID"   -H "Authorization: Bearer $MGMT_TOKEN"   -H "Content-Type: application/json"   -d '{"app_metadata": {"plan": "enterprise", "custom_data": {"key": "value"}}}'

---

Gestion des rôles

Cette section explique comment automatiser l’attribution de rôles et la récupération des rôles disponibles pour la gestion des droits des utilisateurs.

# Assigner un rôle à un utilisateur
async def assign_role(mgmt_token, domain, user_id, role_id):
    url = f"https://{domain}/api/v2/users/{user_id}/roles"
    await httpx.AsyncClient().post(
        url,
        headers={"Authorization": f"Bearer {mgmt_token}"},
        json={"roles": [role_id]},
    )

# Lister les rôles disponibles
async def list_roles(mgmt_token, domain):
    url = f"https://{domain}/api/v2/roles"
    resp = await httpx.AsyncClient().get(
        url,
        headers={"Authorization": f"Bearer {mgmt_token}"},
        params={"per_page": 50},
    )
    return resp.json()

Ce code gère l’affectation d’un rôle à un utilisateur et la récupération de tous les rôles existants.

---

Export des logs

Ici, vous pouvez exporter l’historique des logs d’Auth0 pour audit ou analyse de sécurité, en batchant les résultats pour contourner le rate limit.

import asyncio

async def export_all_logs(mgmt_token: str, domain: str, from_date: str):
    """Exporte tous les logs depuis une date donnée."""
    logs = []
    checkpoint = None

    async with httpx.AsyncClient() as client:
        while True:
            params = {
                "per_page": 100,
                "q": f"date:[{from_date} TO *]",
                "sort": "date:1",
            }
            if checkpoint:
                params["from"] = checkpoint
                params["take"] = 100

            resp = await client.get(
                f"https://{domain}/api/v2/logs",
                headers={"Authorization": f"Bearer {mgmt_token}"},
                params=params,
            )
            batch = resp.json()
            if not batch:
                break
            logs.extend(batch)
            checkpoint = batch[-1]["_id"]
            await asyncio.sleep(0.5)  # Respecter le rate limit

    return logs

Ce code exporte tous les logs Auth0 à partir d’une date précise, quel que soit le volume, tout en respectant les limitations d’API.

---

Scopes Management API utiles

Voici les permissions (scopes) à accorder à votre application pour automatiser la gestion des utilisateurs, rôles et logs.

| Scope | Action | |-------|--------| | read:users | Lire les profils utilisateurs | | update:users | Modifier profils et metadata | | create:users | Créer des utilisateurs | | read:logs | Accéder aux logs d'authentification | | read:roles | Lister les rôles | | update:roles | Assigner/retirer des rôles | | read:connections | Lister les connexions | | create:organizations | Créer des organizations |

---

Rate Limits à connaître

Auth0 impose des limitations pour protéger l’API : connaître les quotas évite les interruptions.

| Endpoint | Limite | Fenêtre | |----------|--------|---------| | GET /users | 20 req | Par seconde | | POST /users | 10 req | Par seconde | | PATCH /users | 20 req | Par seconde | | GET /logs | 5 req | Par seconde |

Gestion des 429 : Ce code montre comment automatiser la gestion des erreurs de limitation (HTTP 429) en réessayant après le délai imposé.

import time

async def api_call_with_retry(url, **kwargs):
    for attempt in range(3):
        resp = await httpx.AsyncClient().get(url, **kwargs)
        if resp.status_code == 429:
            retry_after = int(resp.headers.get("x-ratelimit-reset", 60))
            await asyncio.sleep(retry_after - time.time() + 1)
            continue
        return resp
    raise Exception("Rate limit persistant")

---

> ⚙️ Migration de masse d'utilisateurs ? Nous avons migré jusqu'à 50 millions d'utilisateurs via la Management API avec zéro perte de données.

📞 +33 1 23 45 67 89 · 📧 [email protected]