--- title: "Connettore Auth0" description: "Guida completa all'integrazione di Auth0 per sincronizzare dati di autenticazione utenti, profili identità ed eventi di accesso con Brevo tramite Tajo." url: https://tajo.io/it/docs/connectors/custom/auth0/ markdown: https://tajo.io/it/docs/connectors/custom/auth0.md lang: it-IT robots: noindex --- Richiedi l’accesso anticipato Inserisci il tuo nome e indirizzo email aziendale. Ti invieremo un link per confermare la richiesta di accesso a Tajo. # Connettore Auth0 Stato del connettore: Pianificato Non ancora realizzato. Oggi Tajo non esegue questo connettore. | Campo di origine | Campo di destinazione | Valore di esempio | | --- | --- | --- | | `record.id` | `source_id` | `record_1042` | | `record.updated_at` | `updated_at` | `2026-10-18T08:00:00Z` | | `record.value` | `value` | `sample_value` | Collega Auth0 a Brevo tramite Tajo per sincronizzare i profili utente autenticati come contatti marketing, attivare automazioni basate su eventi di autenticazione e arricchire i dati clienti con insight di identity e access management. ## Panoramica | Proprietà | Valore | | --- | --- | | **Piattaforma** | Auth0 (by Okta) | | **Categoria** | Identity & Access (Custom) | | **Complessità di setup** | Media | | **Integrazione ufficiale** | No | | **Dati sincronizzati** | Utenti, Eventi, Ruoli, Identità | | **Metodo di autenticazione** | Machine-to-Machine OAuth 2.0 | ## Funzionalità - **Sync profilo utente** - Sincronizza i profili utente Auth0 con i contatti Brevo - **Eventi di autenticazione** - Attiva automazioni su login, signup e reset password - **Segmentazione basata su ruoli** - Segmenta i contatti in base a ruoli e permessi Auth0 - **Dati di identità social** - Arricchisci i contatti con le informazioni di profilo dei login social - **Tracciamento attività di login** - Traccia ultimo login, conteggio login e dati del dispositivo - **Supporto multi-tenant** - Sincronizza utenti su più tenant Auth0 ## Prerequisiti Prima di iniziare, assicurati di avere: 1. Un account Auth0 con accesso API 2. Un’applicazione Machine-to-Machine registrata in Auth0 3. I permessi della Management API concessi all’applicazione M2M 4. Un account Brevo con accesso API 5. Un account Tajo con i permessi sui connettori ## Autenticazione ### Machine-to-Machine OAuth 2.0 ```bash # Crea un'applicazione M2M nella Dashboard 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 // Ottiene un access token per 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(); // Il token è valido 24 ore di default ``` Permessi API Concedi alla tua applicazione M2M solo gli scope necessari: `read:users`, `read:user_idp_tokens`, `read:roles` e `read:logs`. Evita di concedere permessi di scrittura se non servono. ## Configurazione ### Setup di 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 * * *" # Ogni 4 ore lists: all_users: 20 verified_users: 21 social_login: 22 ``` ### Mapping dei campi ```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 ``` ## Endpoint API | Endpoint | Metodo | Descrizione | | --- | --- | --- | | `https://{domain}/api/v2/users` | GET | Elenca o cerca utenti | | `https://{domain}/api/v2/users/{id}` | GET | Ottieni un utente | | `https://{domain}/api/v2/users/{id}` | PATCH | Aggiorna metadati utente | | `https://{domain}/api/v2/users/{id}/roles` | GET | Ottieni i ruoli utente | | `https://{domain}/api/v2/roles` | GET | Elenca tutti i ruoli | | `https://{domain}/api/v2/logs` | GET | Ottieni eventi di log | | `https://{domain}/api/v2/stats/active-users` | GET | Ottieni il numero di utenti attivi | | `https://{domain}/api/v2/stats/daily` | GET | Ottieni statistiche giornaliere | | `https://{domain}/oauth/token` | POST | Ottieni un access token | ## Esempi di codice ### Inizializzare il connettore ```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 }); ``` ### Sincronizzare gli utenti su Brevo ```javascript // Paginazione sugli utenti 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; } ``` ### Tracciare eventi di autenticazione tramite Log Streams ```javascript // Configura un webhook Log Stream di Auth0 // Configuralo nella Dashboard Auth0 > Monitoring > Streams app.post('/webhooks/auth0', async (req, res) => { // Verifica l'header di autorizzazione 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': // Login riuscito 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': // Signup riuscito await tajo.contacts.sync({ email: log.data.details.email, attributes: { SIGNUP_DATE: log.data.date }, listIds: [20] }); break; case 'sp': // Cambio password riuscito await tajo.events.track({ email: log.data.details.email, event: 'password_changed' }); break; } } res.status(200).send('OK'); }); ``` ### Segmentazione basata sui ruoli ```javascript // Sincronizza i ruoli utente per la segmentazione 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') } }); ``` ## Limiti di rate | Categoria endpoint | Limite | Note | | --- | --- | --- | | Management API | 50 req/sec (Free) | Per tenant | | Management API | 100 req/sec (Paid) | Per tenant | | Authentication API | Variabile | In base al piano | | Log Streams | Real-time | Nessun limite di rate sulla consegna | | Paginazione | 50 elementi/pagina max | Usa i parametri `page` e `per_page` | Paginazione obbligatoria La Management API di Auth0 restituisce al massimo 50 risultati per pagina. Implementa sempre la paginazione con i parametri `page` e `per_page`. Aggiungi `include_totals=true` per ottenere il conteggio totale. ## Risoluzione dei problemi | Problema | Causa | Soluzione | | --- | --- | --- | | 401 Unauthorized | Token scaduto | Richiedi un nuovo token M2M (scadenza 24h) | | 403 Forbidden | Scope mancanti | Concedi i permessi richiesti all’app M2M | | Elenco utenti vuoto | Errore nella search query | Usa la sintassi Lucene per il motore v3 | | Metadati mancanti | Metadati non impostati | Controlla user\_metadata e app\_metadata | | Rate limit 429 | Troppe richieste | Implementa backoff con gli header di retry | ### Modalità debug ```yaml connectors: auth0: debug: true log_level: verbose log_sync: true ``` ## Best practice 1. **Usa i Log Streams** - Streaming di eventi in real-time invece di polling della Logs API 2. **Implementa la paginazione** - Pagina sempre le query sulla lista utenti per tenant grandi 3. **Memorizza in cache i token M2M** - Riutilizza i token fino a prossima scadenza (24h di default) 4. **Usa il search engine v3** - Usa la sintassi Lucene per ricerche utenti efficienti 5. **Sincronizza solo utenti verificati** - Filtra su `email_verified:true` per evitare contatti non verificati 6. **Sfrutta i metadati utente** - Memorizza attributi personalizzati in user\_metadata di Auth0 per il sync ## Sicurezza - **Machine-to-Machine OAuth** - Client credentials grant per auth server-to-server - **Permessi con scope** - Concedi gli scope minimi richiesti dalla Management API - **Rotazione token** - I token M2M scadono dopo 24 ore di default - **Autenticazione Log Stream** - Usa verifica bearer token sugli endpoint webhook - **Isolamento tenant** - Configurazioni separate per ogni tenant Auth0 - **Trasporto cifrato** - TLS 1.2+ per tutte le comunicazioni API ## Risorse correlate - [Connettore Segment](https://tajo.io/it/docs/connectors/custom/segment) - [Connettore Zapier](https://tajo.io/it/docs/connectors/custom/zapier) - [Skill Customer Sync](https://tajo.io/it/docs/skills/data-sync/customer-sync) - [Documentazione Auth0 Management API](https://auth0.com/docs/api/management/v2)