---
title: "Auth0 Connector"
description: "Vollständiger Leitfaden zur Auth0-Integration für die Synchronisierung von Authentifizierungsdaten, Identitätsprofilen und Zugriffs-Events mit Brevo über Tajo."
url: https://tajo.io/de/docs/connectors/custom/auth0/
markdown: https://tajo.io/de/docs/connectors/custom/auth0.md
lang: de-DE
robots: noindex
---

Beantrage frühzeitigen Zugang

Gib deinen Vornamen und deine geschäftliche E-Mail-Adresse ein. Wir senden dir einen Link, mit dem du deine Anfrage für den Tajo-Zugang bestätigst.

# Auth0 Connector

Connector-Status: Geplant Noch nicht gebaut. Tajo betreibt diesen Connector heute nicht.

| Quellfeld | Zielfeld | Beispielwert |
| --- | --- | --- |
| `record.id` | `source_id` | `record_1042` |
| `record.updated_at` | `updated_at` | `2026-10-18T08:00:00Z` |
| `record.value` | `value` | `sample_value` |

Verbinde Auth0 über Tajo mit Brevo, um authentifizierte Nutzer:innen-Profile als Marketingkontakte zu synchronisieren, Automatisierungen auf Basis von Authentifizierungsereignissen auszulösen und deine Kundendaten um Identitäts- und Zugriffsinformationen anzureichern.

## Überblick

| Eigenschaft | Wert |
| --- | --- |
| **Plattform** | Auth0 (von Okta) |
| **Kategorie** | Identity & Access (Custom) |
| **Einrichtungsaufwand** | Mittel |
| **Offizielle Integration** | Nein |
| **Synchronisierte Daten** | Nutzer:innen, Events, Rollen, Identitäten |
| **Auth-Methode** | Machine-to-Machine OAuth 2.0 |

## Funktionen

- **Synchronisierung von Nutzer:innen-Profilen** - Synchronisiere Auth0-Nutzer:innen-Profile mit Brevo-Kontakten
- **Authentifizierungs-Events** - Löse Automatisierungen bei Login, Signup und Passwort-Reset aus
- **Rollenbasierte Segmentierung** - Segmentiere Kontakte anhand von Auth0-Rollen und -Berechtigungen
- **Daten sozialer Identitäten** - Reichere Kontakte mit Profilinformationen aus sozialen Logins an
- **Login-Aktivitäts-Tracking** - Verfolge letzten Login, Login-Anzahl und Gerätedaten
- **Multi-Tenant-Unterstützung** - Synchronisiere Nutzer:innen über mehrere Auth0-Tenants hinweg

## Voraussetzungen

Bevor du beginnst, stelle sicher, dass du Folgendes hast:

1. Ein Auth0-Konto mit API-Zugriff
2. Eine in Auth0 registrierte Machine-to-Machine-Anwendung
3. Management-API-Berechtigungen für die M2M-Anwendung
4. Ein Brevo-Konto mit API-Zugriff
5. Ein Tajo-Konto mit Connector-Berechtigungen

## Authentifizierung

### Machine-to-Machine OAuth 2.0

```bash
# Create an M2M application in Auth0 Dashboard
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
// Get Management API access token
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();
// Token is valid for 24 hours by default
```

API-Berechtigungen

Gewähre deiner M2M-Anwendung nur die erforderlichen Scopes: `read:users`, `read:user_idp_tokens`, `read:roles` und `read:logs`. Vermeide Schreibberechtigungen, sofern nicht erforderlich.

## Konfiguration

### Grundeinrichtung

```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 * * *"  # Every 4 hours

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

### Feldzuordnung

```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
```

## API-Endpunkte

| Endpunkt | Methode | Beschreibung |
| --- | --- | --- |
| `https://{domain}/api/v2/users` | GET | Nutzer:innen auflisten oder suchen |
| `https://{domain}/api/v2/users/{id}` | GET | Nutzer:in abrufen |
| `https://{domain}/api/v2/users/{id}` | PATCH | Nutzer:innen-Metadaten aktualisieren |
| `https://{domain}/api/v2/users/{id}/roles` | GET | Rollen eines Nutzers/einer Nutzerin abrufen |
| `https://{domain}/api/v2/roles` | GET | Alle Rollen auflisten |
| `https://{domain}/api/v2/logs` | GET | Log-Events abrufen |
| `https://{domain}/api/v2/stats/active-users` | GET | Anzahl aktiver Nutzer:innen abrufen |
| `https://{domain}/api/v2/stats/daily` | GET | Tägliche Statistiken abrufen |
| `https://{domain}/oauth/token` | POST | Access Token abrufen |

## Code-Beispiele

### Connector initialisieren

```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
});
```

### Nutzer:innen mit Brevo synchronisieren

```javascript
// Paginate through Auth0 users
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;
}
```

### Authentifizierungs-Events über Log-Streams verfolgen

```javascript
// Set up Auth0 Log Stream webhook
// Configure in Auth0 Dashboard > Monitoring > Streams

app.post('/webhooks/auth0', async (req, res) => {
  // Verify authorization header
  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':   // Successful login
        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':  // Successful signup
        await tajo.contacts.sync({
          email: log.data.details.email,
          attributes: { SIGNUP_DATE: log.data.date },
          listIds: [20]
        });
        break;
      case 'sp':  // Successful password change
        await tajo.events.track({
          email: log.data.details.email,
          event: 'password_changed'
        });
        break;
    }
  }

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

### Rollenbasierte Segmentierung

```javascript
// Sync user roles for 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')
  }
});
```

## Ratenbegrenzungen

| Endpunkt-Kategorie | Limit | Hinweise |
| --- | --- | --- |
| Management API | 50 Anf./Sek. (Free) | Pro Tenant |
| Management API | 100 Anf./Sek. (Paid) | Pro Tenant |
| Authentication API | Variiert | Abhängig vom Plan |
| Log Streams | Echtzeit | Keine Ratenbegrenzung für die Zustellung |
| Paginierung | Max. 50 Objekte/Seite | Parameter `page` und `per_page` verwenden |

Paginierung erforderlich

Die Auth0 Management API liefert maximal 50 Ergebnisse pro Seite zurück. Implementiere stets Paginierung mit den Parametern `page` und `per_page`. Setze `include_totals=true`, um die Gesamtanzahl zu erhalten.

## Fehlerbehebung

| Problem | Ursache | Lösung |
| --- | --- | --- |
| 401 Unauthorized | Token abgelaufen | Neues M2M-Token anfordern (24h-Gültigkeit) |
| 403 Forbidden | Fehlende Scopes | Erforderliche Berechtigungen der M2M-App erteilen |
| Leere Nutzer:innen-Liste | Fehler in der Suchanfrage | Lucene-Query-Syntax für die v3-Engine verwenden |
| Fehlende Metadaten | Metadaten nicht gesetzt | `user_metadata` und `app_metadata` prüfen |
| Rate Limit 429 | Zu viele Anfragen | Backoff mit Retry-Headern implementieren |

### Debug-Modus

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

## Best Practices

1. **Log Streams nutzen** - Echtzeit-Event-Streaming statt Polling der Logs-API
2. **Paginierung implementieren** - Paginiere Nutzer:innen-Abfragen in großen Tenants immer
3. **M2M-Tokens zwischenspeichern** - Nutze Tokens wieder, bis sie kurz vor Ablauf stehen (Standard 24h Lebensdauer)
4. **Such-Engine v3 verwenden** - Verwende die Lucene-Query-Syntax für effiziente Nutzer:innen-Suchen
5. **Nur verifizierte Nutzer:innen synchronisieren** - Filtere auf `email_verified:true`, um unverifizierte Kontakte zu vermeiden
6. **Nutzer:innen-Metadaten nutzen** - Speichere benutzerdefinierte Attribute in Auth0 `user_metadata` zur Synchronisierung

## Sicherheit

- **Machine-to-Machine OAuth** - Client-Credentials-Grant für Server-zu-Server-Authentifizierung
- **Eingeschränkte Berechtigungen** - Erteile nur die minimal erforderlichen Management-API-Scopes
- **Token-Rotation** - M2M-Tokens laufen standardmäßig nach 24 Stunden ab
- **Log-Stream-Authentifizierung** - Bearer-Token-Verifizierung für Webhook-Endpunkte nutzen
- **Tenant-Isolation** - Getrennte Konfigurationen pro Auth0-Tenant
- **Verschlüsselter Transport** - TLS 1.2+ für die gesamte API-Kommunikation

## Verwandte Ressourcen

- [Segment Connector](https://tajo.io/de/docs/connectors/custom/segment)
- [Zapier Connector](https://tajo.io/de/docs/connectors/custom/zapier)
- [Customer-Sync-Skill](https://tajo.io/de/docs/skills/data-sync/customer-sync)
- [Auth0 Management API-Dokumentation](https://auth0.com/docs/api/management/v2)