Bed om tidlig adgang til Tajo

Indtast dit fornavn og en e-mailadresse eller et telefonnummer. Vi kontakter dig med oplysninger om adgang til Tajo.

Auth0 Connector

Forbind Auth0 med Brevo gennem Tajo for at synkronisere autentificerede brugerprofiler som marketingkontakter, udløse automatiseringer baseret på autentifikationshændelser og berige dine kundedata med indsigter fra identitets- og adgangsstyring.

Oversigt

Egenskab	Værdi
Platform	Auth0 (af Okta)
Kategori	Identitet & adgang (brugerdefineret)
Opsætningskompleksitet	Medium
Officiel integration	Nej
Synkroniserede data	Brugere, hændelser, roller, identiteter
Autentifikationsmetode	Machine-to-Machine OAuth 2.0

Funktioner

Synkronisering af brugerprofiler - Synkronisér Auth0-brugerprofiler til Brevo-kontakter
Autentifikationshændelser - Udløs automatiseringer ved login, tilmelding og adgangskodenulstilling
Rollebaseret segmentering - Segmentér kontakter baseret på Auth0-roller og tilladelser
Data om sociale identiteter - Berig kontakter med profiloplysninger fra sociale login
Sporing af loginaktivitet - Spor sidste login, antal logins og enhedsdata
Multi-tenant-understøttelse - Synkronisér brugere på tværs af flere Auth0-tenants

Forudsætninger

Før du begynder, skal du sikre dig, at du har:

En Auth0-konto med API-adgang
En Machine-to-Machine-applikation registreret i Auth0
Management API-tilladelser tildelt M2M-applikationen
En Brevo-konto med API-adgang
En Tajo-konto med connector-tilladelser

Autentifikation

Machine-to-Machine OAuth 2.0

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

// 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-tilladelser

Giv kun de nødvendige scopes til din M2M-applikation: read:users, read:user_idp_tokens, read:roles og read:logs. Undgå at give skrivetilladelser, medmindre det er nødvendigt.

Konfiguration

Grundlæggende opsætning

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

Feltmapping

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

Endpoint	Metode	Beskrivelse
`https://{domain}/api/v2/users`	GET	Vis eller søg brugere
`https://{domain}/api/v2/users/{id}`	GET	Hent en bruger
`https://{domain}/api/v2/users/{id}`	PATCH	Opdatér brugermetadata
`https://{domain}/api/v2/users/{id}/roles`	GET	Hent brugerroller
`https://{domain}/api/v2/roles`	GET	Vis alle roller
`https://{domain}/api/v2/logs`	GET	Hent log-hændelser
`https://{domain}/api/v2/stats/active-users`	GET	Hent antal aktive brugere
`https://{domain}/api/v2/stats/daily`	GET	Hent daglige statistikker
`https://{domain}/oauth/token`	POST	Hent adgangstoken

Kodeeksempler

Initialisér connector

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

Synkronisér brugere til Brevo

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

Spor autentifikationshændelser via Log Streams

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

Rollebaseret segmentering

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

Rate limits

Endpoint-kategori	Grænse	Noter
Management API	50 anmodninger/sek. (Free)	Pr. tenant
Management API	100 anmodninger/sek. (betalt)	Pr. tenant
Authentication API	Varierer	Baseret på plan
Log Streams	Realtid	Ingen rate limit ved levering
Paginering	Maks. 50 elementer/side	Brug parametrene `page` og `per_page`

Paginering påkrævet

Auth0 Management API returnerer maksimalt 50 resultater pr. side. Implementér altid paginering ved hjælp af parametrene page og per_page. Inkludér include_totals=true for at få det samlede antal.

Fejlfinding

Problem	Årsag	Løsning
401 Unauthorized	Token udløbet	Anmod om nyt M2M-token (24t udløb)
403 Forbidden	Manglende scopes	Giv de nødvendige tilladelser til M2M-appen
Tom brugerliste	Fejl i søgeforespørgsel	Brug Lucene-forespørgselssyntaks til v3-motoren
Manglende metadata	Metadata ikke angivet	Kontrollér user_metadata og app_metadata
Rate limit 429	For mange anmodninger	Implementér backoff med retry-headers

Debug-tilstand

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

Bedste praksis

Brug Log Streams - Hændelsesstreaming i realtid i stedet for at polle Logs API’et
Implementér paginering - Paginér altid brugerforespørgsler for store tenants
Cache M2M-tokens - Genbrug tokens indtil tæt på udløb (24t standardlevetid)
Brug søgemotor v3 - Brug Lucene-forespørgselssyntaks til effektive brugersøgninger
Synkronisér kun verificerede brugere - Filtrér på email_verified:true for at undgå ikke-verificerede kontakter
Udnyt brugermetadata - Gem brugerdefinerede attributter i Auth0 user_metadata til synkronisering

Sikkerhed

Machine-to-Machine OAuth - Client credentials grant til server-til-server-autentifikation
Scopes tilladelser - Giv minimum nødvendige Management API-scopes
Token-rotation - M2M-tokens udløber efter 24 timer som standard
Log Stream-autentifikation - Brug bearer-token-verifikation til webhook-endpoints
Tenant-isolation - Separate konfigurationer pr. Auth0-tenant
Krypteret transport - TLS 1.2+ til al API-kommunikation