---
title: "Connecteur Auth0"
description: "Guide complet d'intégration Auth0 pour synchroniser les données d'authentification utilisateur, les profils d'identité et les événements d'accès avec Brevo via Tajo."
url: https://tajo.io/fr/docs/connectors/custom/auth0/
markdown: https://tajo.io/fr/docs/connectors/custom/auth0.md
lang: fr-FR
robots: noindex
---

Demandez un accès anticipé

Indiquez votre prénom et votre adresse e-mail professionnelle. Nous vous enverrons un lien pour confirmer votre demande d’accès à Tajo.

# Connecteur Auth0

Statut du connecteur: Prévu Pas encore construit. Tajo n'exécute pas ce connecteur aujourd'hui.

| Champ source | Champ de destination | Valeur d’exemple |
| --- | --- | --- |
| `record.id` | `source_id` | `record_1042` |
| `record.updated_at` | `updated_at` | `2026-10-18T08:00:00Z` |
| `record.value` | `value` | `sample_value` |

Connectez Auth0 à Brevo via Tajo pour synchroniser les profils utilisateur authentifiés sous forme de contacts marketing, déclencher des automatisations selon les événements d’authentification et enrichir vos données clients avec des informations de gestion des identités et des accès.

## Vue d’ensemble

| Propriété | Valeur |
| --- | --- |
| **Plateforme** | Auth0 (par Okta) |
| **Catégorie** | Gestion des identités et accès (Custom) |
| **Complexité d’installation** | Moyenne |
| **Intégration officielle** | Non |
| **Données synchronisées** | Utilisateurs, événements, rôles, identités |
| **Méthode d’authentification** | Machine-to-Machine OAuth 2.0 |

## Fonctionnalités

- **Synchronisation des profils utilisateur**, Synchronisez les profils utilisateur Auth0 vers les contacts Brevo
- **Événements d’authentification**, Déclenchez des automatisations lors de la connexion, de l’inscription et de la réinitialisation de mot de passe
- **Segmentation basée sur les rôles**, Segmentez les contacts selon les rôles et permissions Auth0
- **Données d’identité sociale**, Enrichissez les contacts avec les informations de profil de connexion sociale
- **Suivi de l’activité de connexion**, Suivez la dernière connexion, le nombre de connexions et les données d’appareil
- **Prise en charge multi-tenant**, Synchronisez les utilisateurs sur plusieurs tenants Auth0

## Prérequis

Avant de commencer, assurez-vous de disposer de :

1. Un compte Auth0 avec accès API
2. Une application Machine-to-Machine enregistrée dans Auth0
3. Les permissions de la Management API accordées à l’application M2M
4. Un compte Brevo avec accès API
5. Un compte Tajo avec les permissions connecteur

## Authentification

### Machine-to-Machine OAuth 2.0

```bash
# Créez une application M2M dans le tableau de bord Auth0
export AUTH0_DOMAIN=your-tenant.auth0.com
export AUTH0_CLIENT_ID=your_client_id
export AUTH0_CLIENT_SECRET=your_client_secret
export AUTH0_AUDIENCE=https://your-tenant.auth0.com/api/v2/
```

```javascript
// Obtenir un token d'accès pour la Management API
const tokenResponse = await fetch(
  `https://${process.env.AUTH0_DOMAIN}/oauth/token`,
  {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      client_id: process.env.AUTH0_CLIENT_ID,
      client_secret: process.env.AUTH0_CLIENT_SECRET,
      audience: process.env.AUTH0_AUDIENCE,
      grant_type: 'client_credentials'
    })
  }
);

const { access_token } = await tokenResponse.json();
// Le token est valide 24 heures par défaut
```

Permissions API

N’accordez à votre application M2M que les scopes requis : `read:users`, `read:user_idp_tokens`, `read:roles` et `read:logs`. Évitez d’accorder des permissions en écriture sauf si nécessaire.

## Configuration

### Configuration de base

```yaml
connectors:
  auth0:
    enabled: true
    domain: "${AUTH0_DOMAIN}"
    client_id: "${AUTH0_CLIENT_ID}"
    client_secret: "${AUTH0_CLIENT_SECRET}"
    audience: "https://${AUTH0_DOMAIN}/api/v2/"

    sync:
      users: true
      events: true
      roles: true
      schedule: "0 */4 * * *"  # Toutes les 4 heures

    lists:
      all_users: 20
      verified_users: 21
      social_login: 22
```

### Mappage des champs

```yaml
field_mapping:
  email: email
  given_name: FIRSTNAME
  family_name: LASTNAME
  nickname: NICKNAME
  picture: AVATAR_URL
  email_verified: EMAIL_VERIFIED
  logins_count: LOGIN_COUNT
  last_login: LAST_LOGIN_DATE
  created_at: SIGNUP_DATE
  user_metadata.phone: SMS
  user_metadata.company: COMPANY
  app_metadata.plan: SUBSCRIPTION_PLAN
  app_metadata.role: USER_ROLE
```

## Endpoints API

| Endpoint | Méthode | Description |
| --- | --- | --- |
| `https://{domain}/api/v2/users` | GET | Lister ou rechercher des utilisateurs |
| `https://{domain}/api/v2/users/{id}` | GET | Obtenir un utilisateur |
| `https://{domain}/api/v2/users/{id}` | PATCH | Mettre à jour les métadonnées utilisateur |
| `https://{domain}/api/v2/users/{id}/roles` | GET | Obtenir les rôles d’un utilisateur |
| `https://{domain}/api/v2/roles` | GET | Lister tous les rôles |
| `https://{domain}/api/v2/logs` | GET | Obtenir les événements de logs |
| `https://{domain}/api/v2/stats/active-users` | GET | Obtenir le nombre d’utilisateurs actifs |
| `https://{domain}/api/v2/stats/daily` | GET | Obtenir les statistiques quotidiennes |
| `https://{domain}/oauth/token` | POST | Obtenir un token d’accès |

## Exemples de code

### Initialiser le connecteur

```javascript
import { TajoClient } from '@tajo/sdk';

const tajo = new TajoClient({
  apiKey: process.env.TAJO_API_KEY,
  brevoApiKey: process.env.BREVO_API_KEY
});

await tajo.connectors.connect('auth0', {
  domain: process.env.AUTH0_DOMAIN,
  clientId: process.env.AUTH0_CLIENT_ID,
  clientSecret: process.env.AUTH0_CLIENT_SECRET
});
```

### Synchroniser les utilisateurs vers Brevo

```javascript
// Paginer les utilisateurs Auth0
let page = 0;
const perPage = 50;
let hasMore = true;

while (hasMore) {
  const response = await fetch(
    `https://${domain}/api/v2/users?` +
      new URLSearchParams({
        page: page.toString(),
        per_page: perPage.toString(),
        include_totals: 'true',
        search_engine: 'v3',
        q: 'email_verified:true'
      }),
    {
      headers: { 'Authorization': `Bearer ${accessToken}` }
    }
  );

  const { users, total } = await response.json();

  for (const user of users) {
    await tajo.contacts.sync({
      email: user.email,
      attributes: {
        FIRSTNAME: user.given_name,
        LASTNAME: user.family_name,
        LOGIN_COUNT: user.logins_count,
        LAST_LOGIN_DATE: user.last_login,
        SIGNUP_DATE: user.created_at,
        EMAIL_VERIFIED: user.email_verified
      },
      listIds: [20]
    });
  }

  page++;
  hasMore = (page * perPage) < total;
}
```

### Suivre les événements d’authentification via les Log Streams

```javascript
// Configurez un webhook Log Stream Auth0
// Configurez dans Auth0 Dashboard > Monitoring > Streams

app.post('/webhooks/auth0', async (req, res) => {
  // Vérifier l'en-tête d'autorisation
  const authHeader = req.headers.authorization;
  if (authHeader !== `Bearer ${process.env.AUTH0_WEBHOOK_TOKEN}`) {
    return res.status(401).send('Unauthorized');
  }

  const logs = req.body;

  for (const log of logs) {
    switch (log.data.type) {
      case 's':   // Connexion réussie
        await tajo.events.track({
          email: log.data.details.email,
          event: 'user_login',
          properties: {
            ip: log.data.ip,
            user_agent: log.data.user_agent,
            connection: log.data.connection
          }
        });
        break;
      case 'ss':  // Inscription réussie
        await tajo.contacts.sync({
          email: log.data.details.email,
          attributes: { SIGNUP_DATE: log.data.date },
          listIds: [20]
        });
        break;
      case 'sp':  // Changement de mot de passe réussi
        await tajo.events.track({
          email: log.data.details.email,
          event: 'password_changed'
        });
        break;
    }
  }

  res.status(200).send('OK');
});
```

### Segmentation basée sur les rôles

```javascript
// Synchroniser les rôles utilisateur pour la segmentation
const rolesResponse = await fetch(
  `https://${domain}/api/v2/users/${userId}/roles`,
  {
    headers: { 'Authorization': `Bearer ${accessToken}` }
  }
);

const roles = await rolesResponse.json();
const roleNames = roles.map(r => r.name).join(', ');

await tajo.contacts.update(userEmail, {
  attributes: {
    USER_ROLE: roleNames,
    IS_ADMIN: roles.some(r => r.name === 'admin')
  }
});
```

## Limites de débit

| Catégorie d’endpoint | Limite | Notes |
| --- | --- | --- |
| Management API | 50 req/s (Free) | Par tenant |
| Management API | 100 req/s (Payant) | Par tenant |
| Authentication API | Variable | Selon le plan |
| Log Streams | Temps réel | Pas de limite de débit en livraison |
| Pagination | 50 éléments/page max | Utilisez les paramètres `page` et `per_page` |

Pagination requise

La Management API d’Auth0 renvoie un maximum de 50 résultats par page. Implémentez toujours la pagination avec les paramètres `page` et `per_page`. Incluez `include_totals=true` pour obtenir le total.

## Dépannage

| Problème | Cause | Solution |
| --- | --- | --- |
| 401 Unauthorized | Token expiré | Demandez un nouveau token M2M (expire après 24 h) |
| 403 Forbidden | Scopes manquants | Accordez les permissions requises à l’app M2M |
| Liste d’utilisateurs vide | Erreur dans la requête de recherche | Utilisez la syntaxe Lucene pour le moteur v3 |
| Métadonnées manquantes | Métadonnées non définies | Vérifiez user\_metadata et app\_metadata |
| Limite de débit 429 | Trop de requêtes | Implémentez un backoff avec les en-têtes retry |

### Mode debug

```yaml
connectors:
  auth0:
    debug: true
    log_level: verbose
    log_sync: true
```

## Bonnes pratiques

1. **Utilisez les Log Streams**, Streaming d’événements en temps réel plutôt qu’un polling de l’API Logs
2. **Implémentez la pagination**, Paginez toujours les requêtes sur les listes d’utilisateurs pour les grands tenants
3. **Mettez en cache les tokens M2M**, Réutilisez les tokens jusqu’à leur expiration (durée de vie par défaut 24 h)
4. **Utilisez le moteur de recherche v3**, Utilisez la syntaxe Lucene pour des recherches utilisateur efficaces
5. **Synchronisez uniquement les utilisateurs vérifiés**, Filtrez sur `email_verified:true` pour éviter les contacts non vérifiés
6. **Exploitez les métadonnées utilisateur**, Stockez les attributs personnalisés dans user\_metadata Auth0 pour la synchronisation

## Sécurité

- **Machine-to-Machine OAuth**, Grant client\_credentials pour l’authentification serveur-à-serveur
- **Permissions à portée limitée**, Accordez les scopes Management API minimum requis
- **Rotation des tokens**, Les tokens M2M expirent au bout de 24 heures par défaut
- **Auth Log Stream**, Utilisez la vérification par bearer token pour les endpoints webhook
- **Isolation des tenants**, Configurations séparées par tenant Auth0
- **Transport chiffré**, TLS 1.2+ pour toutes les communications API

## Ressources associées

- [Connecteur Segment](https://tajo.io/fr/docs/connectors/custom/segment)
- [Connecteur Zapier](https://tajo.io/fr/docs/connectors/custom/zapier)
- [Skill de synchronisation client](https://tajo.io/fr/docs/skills/data-sync/customer-sync)
- [Documentation Auth0 Management API](https://auth0.com/docs/api/management/v2)