Ajukan akses awal

Masukkan nama depan serta email atau nomor telepon Anda. Kami akan menghubungi Anda dengan detail akses Tajo.

Konektor Auth0

Hubungkan Auth0 ke Brevo melalui Tajo untuk menyinkronkan profil pengguna terautentikasi sebagai contact marketing, memicu otomatisasi berdasarkan event autentikasi, dan memperkaya data pelanggan Anda dengan wawasan identity and access management.

Ikhtisar

Properti	Nilai
Platform	Auth0 (dari Okta)
Kategori	Identity & Access (Kustom)
Kompleksitas penyiapan	Sedang
Integrasi resmi	Tidak
Data yang disinkronkan	Users, Events, Roles, Identities
Metode autentikasi	Machine-to-Machine OAuth 2.0

Fitur

Sync profil pengguna - Sinkronkan profil pengguna Auth0 ke contacts Brevo
Event autentikasi - Picu otomatisasi saat login, signup, dan reset password
Segmentasi berbasis role - Segmentasikan contacts berdasarkan role dan permission Auth0
Data identitas sosial - Perkaya contacts dengan informasi profil social login
Pelacakan aktivitas login - Lacak login terakhir, jumlah login, dan data perangkat
Dukungan multi-tenant - Sinkronkan pengguna dari beberapa tenant Auth0

Prasyarat

Sebelum memulai, pastikan Anda memiliki:

Akun Auth0 dengan akses API
Aplikasi Machine-to-Machine yang terdaftar di Auth0
Permission Management API yang diberikan kepada aplikasi M2M tersebut
Akun Brevo dengan akses API
Akun Tajo dengan permission konektor

Autentikasi

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

Permission API

Berikan hanya scope yang diperlukan kepada aplikasi M2M Anda: read:users, read:user_idp_tokens, read:roles, dan read:logs. Hindari memberikan permission tulis kecuali memang dibutuhkan.

Konfigurasi

Penyiapan dasar

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

Pemetaan field

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	Method	Deskripsi
`https://{domain}/api/v2/users`	GET	Menampilkan atau mencari pengguna
`https://{domain}/api/v2/users/{id}`	GET	Mengambil satu pengguna
`https://{domain}/api/v2/users/{id}`	PATCH	Memperbarui metadata pengguna
`https://{domain}/api/v2/users/{id}/roles`	GET	Mengambil role pengguna
`https://{domain}/api/v2/roles`	GET	Menampilkan semua role
`https://{domain}/api/v2/logs`	GET	Mengambil event log
`https://{domain}/api/v2/stats/active-users`	GET	Mengambil jumlah pengguna aktif
`https://{domain}/api/v2/stats/daily`	GET	Mengambil statistik harian
`https://{domain}/oauth/token`	POST	Mengambil access token

Contoh kode

Inisialisasi konektor

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

Menyinkronkan pengguna ke 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;
}

Melacak event autentikasi lewat 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');
});

Segmentasi berbasis role

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

Batas rate

Kategori endpoint	Batas	Catatan
Management API	50 req/detik (Free)	Per tenant
Management API	100 req/detik (berbayar)	Per tenant
Authentication API	Bervariasi	Bergantung pada paket
Log Streams	Real-time	Tanpa rate limit pada pengiriman
Paginasi	Maksimal 50 item/halaman	Gunakan parameter `page` dan `per_page`

Paginasi wajib

Auth0 Management API mengembalikan maksimal 50 hasil per halaman. Selalu terapkan paginasi menggunakan parameter page dan per_page. Sertakan include_totals=true untuk memperoleh jumlah total.

Pemecahan masalah

Masalah	Penyebab	Solusi
401 Unauthorized	Token kedaluwarsa	Minta token M2M baru (masa berlaku 24 jam)
403 Forbidden	Scope tidak lengkap	Berikan permission yang diperlukan ke aplikasi M2M
Daftar pengguna kosong	Query pencarian salah	Gunakan sintaks query Lucene untuk engine v3
Metadata tidak ada	Metadata belum disetel	Periksa user_metadata dan app_metadata
Rate limit 429	Terlalu banyak request	Terapkan backoff dengan memakai header retry

Mode debug

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

Praktik terbaik

Gunakan Log Streams - Streaming event real-time alih-alih polling Logs API
Terapkan paginasi - Selalu paginasikan query daftar pengguna untuk tenant berukuran besar
Cache token M2M - Gunakan ulang token sampai mendekati masa kedaluwarsa (default 24 jam)
Gunakan search engine v3 - Gunakan sintaks query Lucene agar pencarian pengguna efisien
Sinkronkan hanya pengguna terverifikasi - Filter dengan email_verified:true agar contact belum terverifikasi tidak ikut
Manfaatkan metadata pengguna - Simpan atribut kustom di user_metadata Auth0 untuk keperluan sync

Keamanan

Machine-to-Machine OAuth - Client credentials grant untuk autentikasi antar-server
Permission ber-scope - Berikan scope Management API seminimal mungkin
Rotasi token - Token M2M kedaluwarsa setelah 24 jam secara default
Autentikasi Log Stream - Gunakan verifikasi bearer token untuk endpoint webhook
Isolasi tenant - Konfigurasi terpisah untuk setiap tenant Auth0
Transport terenkripsi - TLS 1.2+ untuk semua komunikasi API