---
title: "Conector de Auth0"
description: "Guía completa de integración con Auth0 para sincronizar datos de autenticación de usuarios, perfiles de identidad y eventos de acceso con Brevo a través de Tajo."
url: https://tajo.io/es/docs/connectors/custom/auth0/
markdown: https://tajo.io/es/docs/connectors/custom/auth0.md
lang: es-ES
robots: noindex
---

Solicita acceso anticipado

Escribe tu nombre y dirección de correo de trabajo. Te enviaremos un enlace para confirmar tu solicitud de acceso a Tajo.

# Conector de Auth0

Estado del conector: Planificado Aún no está construido. Tajo no ejecuta este conector hoy.

| Campo de origen | Campo de destino | Valor de ejemplo |
| --- | --- | --- |
| `record.id` | `source_id` | `record_1042` |
| `record.updated_at` | `updated_at` | `2026-10-18T08:00:00Z` |
| `record.value` | `value` | `sample_value` |

Conecta Auth0 con Brevo a través de Tajo para sincronizar los perfiles de usuarios autenticados como contactos de marketing, activar automatizaciones a partir de eventos de autenticación y enriquecer tus datos de clientes con información de gestión de identidades y accesos.

## Resumen

| Propiedad | Valor |
| --- | --- |
| **Plataforma** | Auth0 (de Okta) |
| **Categoría** | Identidad y Acceso (Personalizada) |
| **Complejidad de configuración** | Media |
| **Integración oficial** | No |
| **Datos sincronizados** | Usuarios, Eventos, Roles, Identidades |
| **Método de autenticación** | OAuth 2.0 Machine-to-Machine |

## Funcionalidades

- **Sincronización de perfiles de usuario** - Sincroniza los perfiles de Auth0 con contactos de Brevo
- **Eventos de autenticación** - Activa automatizaciones en el login, registro y restablecimiento de contraseña
- **Segmentación por roles** - Segmenta contactos según los roles y permisos de Auth0
- **Datos de identidad social** - Enriquece contactos con información del perfil de login social
- **Seguimiento de actividad de login** - Rastrea el último login, conteo de logins y datos de dispositivo
- **Soporte multi-tenant** - Sincroniza usuarios entre varios tenants de Auth0

## Requisitos previos

Antes de empezar, asegúrate de tener:

1. Una cuenta de Auth0 con acceso a la API
2. Una aplicación Machine-to-Machine registrada en Auth0
3. Permisos de la Management API concedidos a la aplicación M2M
4. Una cuenta de Brevo con acceso a la API
5. Una cuenta de Tajo con permisos de conector

## Autenticación

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

Permisos de la API

Concede solo los scopes necesarios a tu aplicación M2M: `read:users`, `read:user_idp_tokens`, `read:roles` y `read:logs`. Evita conceder permisos de escritura salvo que sea imprescindible.

## Configuración

### Configuración básica

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

### Asignación de campos

```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 de la API

| Endpoint | Método | Descripción |
| --- | --- | --- |
| `https://{domain}/api/v2/users` | GET | Listar o buscar usuarios |
| `https://{domain}/api/v2/users/{id}` | GET | Obtener un usuario |
| `https://{domain}/api/v2/users/{id}` | PATCH | Actualizar los metadatos del usuario |
| `https://{domain}/api/v2/users/{id}/roles` | GET | Obtener los roles del usuario |
| `https://{domain}/api/v2/roles` | GET | Listar todos los roles |
| `https://{domain}/api/v2/logs` | GET | Obtener eventos de log |
| `https://{domain}/api/v2/stats/active-users` | GET | Obtener el número de usuarios activos |
| `https://{domain}/api/v2/stats/daily` | GET | Obtener estadísticas diarias |
| `https://{domain}/oauth/token` | POST | Obtener un token de acceso |

## Ejemplos de código

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

### Sincronizar usuarios con 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;
}
```

### Rastrear eventos de autenticación vía 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');
});
```

### Segmentación basada en roles

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

## Límites de velocidad

| Categoría de endpoint | Límite | Notas |
| --- | --- | --- |
| Management API | 50 req/s (Free) | Por tenant |
| Management API | 100 req/s (Paid) | Por tenant |
| Authentication API | Varía | Según el plan |
| Log Streams | Tiempo real | Sin límite de velocidad en la entrega |
| Paginación | 50 elementos/página máx. | Usa los parámetros `page` y `per_page` |

Paginación obligatoria

La Management API de Auth0 devuelve un máximo de 50 resultados por página. Implementa siempre la paginación usando los parámetros `page` y `per_page`. Incluye `include_totals=true` para obtener el total.

## Resolución de problemas

| Problema | Causa | Solución |
| --- | --- | --- |
| 401 Unauthorized | Token expirado | Solicita un token M2M nuevo (expiración de 24 h) |
| 403 Forbidden | Faltan scopes | Concede los permisos necesarios a la app M2M |
| Lista de usuarios vacía | Error en la query de búsqueda | Usa sintaxis Lucene para el motor v3 |
| Metadatos ausentes | Metadatos no establecidos | Revisa user\_metadata y app\_metadata |
| 429 por límite de velocidad | Demasiadas peticiones | Aplica backoff usando las cabeceras de reintento |

### Modo depuración

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

## Buenas prácticas

1. **Usa Log Streams** - Streaming de eventos en tiempo real en lugar de consultar la Logs API por polling
2. **Implementa paginación** - Pagina siempre las consultas de lista de usuarios en tenants grandes
3. **Cachea los tokens M2M** - Reutiliza los tokens hasta cerca de su expiración (24 h por defecto)
4. **Usa el motor de búsqueda v3** - Usa sintaxis Lucene para búsquedas de usuario eficientes
5. **Sincroniza solo usuarios verificados** - Filtra por `email_verified:true` para evitar contactos sin verificar
6. **Aprovecha user\_metadata** - Guarda atributos personalizados en user\_metadata de Auth0 para sincronizarlos

## Seguridad

- **OAuth Machine-to-Machine** - Flujo client credentials para auth servidor a servidor
- **Permisos con scope** - Concede los scopes mínimos necesarios de la Management API
- **Rotación de tokens** - Los tokens M2M expiran a las 24 horas por defecto
- **Auth de Log Stream** - Usa verificación por bearer token para endpoints de webhook
- **Aislamiento de tenants** - Configuraciones separadas por tenant de Auth0
- **Transporte cifrado** - TLS 1.2+ para toda la comunicación con la API

## Recursos relacionados

- [Conector de Segment](https://tajo.io/es/docs/connectors/custom/segment)
- [Conector de Zapier](https://tajo.io/es/docs/connectors/custom/zapier)
- [Skill de sincronización de clientes](https://tajo.io/es/docs/skills/data-sync/customer-sync)
- [Documentación de la Management API de Auth0](https://auth0.com/docs/api/management/v2)