---
title: "Conector Auth0"
description: "Ghid complet de integrare Auth0 pentru sincronizarea datelor de autentificare a utilizatorilor, profilurilor de identitate și evenimentelor de acces cu Brevo prin Tajo."
url: https://tajo.io/ro/docs/connectors/custom/auth0/
markdown: https://tajo.io/ro/docs/connectors/custom/auth0.md
lang: ro-RO
robots: noindex
---

Solicită acces anticipat

Introduceți prenumele și adresa de e-mail profesională. Vă vom trimite un link pentru a confirma cererea de acces la Tajo.

# Conector Auth0

Starea conectorului: Planificat Încă neconstruit. Tajo nu rulează astăzi acest conector.

| Câmp sursă | Câmp destinație | Valoare exemplu |
| --- | --- | --- |
| `record.id` | `source_id` | `record_1042` |
| `record.updated_at` | `updated_at` | `2026-10-18T08:00:00Z` |
| `record.value` | `value` | `sample_value` |

Conectați Auth0 la Brevo prin Tajo pentru a sincroniza profilurile utilizatorilor autentificați ca contacte de marketing, a declanșa automatizări bazate pe evenimente de autentificare și a îmbogăți datele clienților cu informații din gestionarea identității și accesului.

## Prezentare generală

| Proprietate | Valoare |
| --- | --- |
| **Platformă** | Auth0 (de Okta) |
| **Categorie** | Identitate și acces (Personalizat) |
| **Complexitate configurare** | Medie |
| **Integrare oficială** | Nu |
| **Date sincronizate** | Utilizatori, Evenimente, Roluri, Identități |
| **Metodă de autentificare** | OAuth 2.0 Machine-to-Machine |

## Funcționalități

- **Sincronizare profil utilizator** - Sincronizați profilurile utilizatorilor Auth0 cu contactele Brevo
- **Evenimente de autentificare** - Declanșați automatizări la autentificare, înregistrare și resetarea parolei
- **Segmentare bazată pe roluri** - Segmentați contactele pe baza rolurilor și permisiunilor Auth0
- **Date identitate socială** - Îmbogățiți contactele cu informații de profil din autentificarea socială
- **Urmărire activitate de autentificare** - Urmăriți ultima autentificare, numărul de autentificări și datele dispozitivului
- **Suport multi-tenant** - Sincronizați utilizatori din mai mulți tenanți Auth0

## Cerințe preliminare

Înainte de a începe, asigurați-vă că aveți:

1. Un cont Auth0 cu acces API
2. O aplicație Machine-to-Machine înregistrată în Auth0
3. Permisiuni API de management acordate aplicației M2M
4. Un cont Brevo cu acces API
5. Un cont Tajo cu permisiuni de conector

## Autentificare

### OAuth 2.0 Machine-to-Machine

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

Permisiuni API

Acordați doar scopurile necesare aplicației M2M: `read:users`, `read:user_idp_tokens`, `read:roles` și `read:logs`. Evitați acordarea permisiunilor de scriere dacă nu sunt necesare.

## Configurare

### Configurare de bază

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

### Mapare câmpuri

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

## Puncte finale API

| Punct final | Metodă | Descriere |
| --- | --- | --- |
| `https://{domain}/api/v2/users` | GET | Listează sau caută utilizatori |
| `https://{domain}/api/v2/users/{id}` | GET | Obține un utilizator |
| `https://{domain}/api/v2/users/{id}` | PATCH | Actualizează metadatele utilizatorului |
| `https://{domain}/api/v2/users/{id}/roles` | GET | Obține rolurile utilizatorului |
| `https://{domain}/api/v2/roles` | GET | Listează toate rolurile |
| `https://{domain}/api/v2/logs` | GET | Obține evenimentele de jurnal |
| `https://{domain}/api/v2/stats/active-users` | GET | Obține numărul de utilizatori activi |
| `https://{domain}/api/v2/stats/daily` | GET | Obține statisticile zilnice |
| `https://{domain}/oauth/token` | POST | Obține token de acces |

## Exemple de cod

### Inițializare conector

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

### Sincronizare utilizatori cu Brevo

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

### Urmărire evenimente de autentificare prin Log Streams

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

### Segmentare bazată pe roluri

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

## Limite de rată

| Categorie punct final | Limită | Note |
| --- | --- | --- |
| Management API | 50 cereri/sec (Gratuit) | Per tenant |
| Management API | 100 cereri/sec (Plătit) | Per tenant |
| Authentication API | Variabil | Bazat pe plan |
| Log Streams | Timp real | Fără limită de rată la livrare |
| Paginare | Maxim 50 elemente/pagină | Utilizați parametrii `page` și `per_page` |

Paginare obligatorie

Auth0 Management API returnează maxim 50 rezultate per pagină. Implementați întotdeauna paginarea folosind parametrii `page` și `per_page`. Includeți `include_totals=true` pentru a obține numărul total.

## Depanare

| Problemă | Cauză | Soluție |
| --- | --- | --- |
| 401 Neautorizat | Token expirat | Solicitați un nou token M2M (expirare 24h) |
| 403 Interzis | Scopuri lipsă | Acordați permisiunile necesare aplicației M2M |
| Listă utilizatori goală | Eroare interogare căutare | Utilizați sintaxa Lucene pentru motorul v3 |
| Metadate lipsă | Metadate nesetate | Verificați user\_metadata și app\_metadata |
| Limită rată 429 | Prea multe cereri | Implementați backoff cu anteturile de reîncercare |

### Modul de depanare

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

## Bune practici

1. **Utilizați Log Streams** - Streaming de evenimente în timp real în loc de interogarea API-ului de jurnale
2. **Implementați paginarea** - Paginați întotdeauna interogările de listare a utilizatorilor pentru tenanți mari
3. **Stocați în cache tokenii M2M** - Reutilizați tokenii până aproape de expirare (durată de viață implicită 24h)
4. **Utilizați motorul de căutare v3** - Utilizați sintaxa Lucene pentru căutări eficiente de utilizatori
5. **Sincronizați doar utilizatorii verificați** - Filtrați pe `email_verified:true` pentru a evita contactele neverificate
6. **Valorificați metadatele utilizatorului** - Stocați atribute personalizate în Auth0 user\_metadata pentru sincronizare

## Securitate

- **OAuth Machine-to-Machine** - Grant de credențiale client pentru autentificare server-la-server
- **Permisiuni cu scop limitat** - Acordați scopurile minime necesare din Management API
- **Rotație token** - Tokenii M2M expiră după 24 de ore în mod implicit
- **Autentificare Log Stream** - Utilizați verificare token bearer pentru punctele finale webhook
- **Izolare tenant** - Configurații separate per tenant Auth0
- **Transport criptat** - TLS 1.2+ pentru toate comunicațiile API

## Resurse conexe

- [Conector Segment](https://tajo.io/ro/docs/connectors/custom/segment)
- [Conector Zapier](https://tajo.io/ro/docs/connectors/custom/zapier)
- [Skill Sincronizare clienți](https://tajo.io/ro/docs/skills/data-sync/customer-sync)
- [Documentație Auth0 Management API](https://auth0.com/docs/api/management/v2)