---
title: "Auth0 कनेक्टर"
description: "Tajo के माध्यम से Auth0 user authentication data, identity profiles, और access events को Brevo के साथ sync करने की संपूर्ण integration guide।"
url: https://tajo.io/hi/docs/connectors/custom/auth0/
markdown: https://tajo.io/hi/docs/connectors/custom/auth0.md
lang: hi-IN
robots: noindex
---

अर्ली एक्सेस का अनुरोध करें

अपना पहला नाम और कार्यस्थल का ईमेल पता दर्ज करें। Tajo एक्सेस अनुरोध की पुष्टि के लिए हम आपको एक लिंक ईमेल करेंगे।

# Auth0 कनेक्टर

कनेक्टर की स्थिति: नियोजित अभी बना नहीं है। Tajo आज यह कनेक्टर नहीं चलाता।

| स्रोत फ़ील्ड | गंतव्य फ़ील्ड | नमूना मान |
| --- | --- | --- |
| `record.id` | `source_id` | `record_1042` |
| `record.updated_at` | `updated_at` | `2026-10-18T08:00:00Z` |
| `record.value` | `value` | `sample_value` |

authenticated user profiles को marketing contacts के रूप में sync करने, authentication events के आधार पर automations trigger करने, और identity एवं access management insights से अपने customer data को समृद्ध करने के लिए Tajo के माध्यम से Auth0 को Brevo से कनेक्ट करें।

## अवलोकन

| Property | Value |
| --- | --- |
| **Platform** | Auth0 (by Okta) |
| **Category** | Identity & Access (Custom) |
| **Setup Complexity** | Medium |
| **Official Integration** | No |
| **Data Synced** | Users, Events, Roles, Identities |
| **Auth Method** | Machine-to-Machine OAuth 2.0 |

## विशेषताएं

- **User profile sync** - Auth0 user profiles को Brevo contacts से sync करें
- **Authentication events** - login, signup, और password reset पर automations trigger करें
- **Role-based segmentation** - Auth0 roles और permissions के आधार पर contacts segment करें
- **Social identity data** - social login profile जानकारी से contacts को समृद्ध करें
- **Login activity tracking** - last login, login count, और device data ट्रैक करें
- **Multi-tenant support** - कई Auth0 tenants में users sync करें

## पूर्वावश्यकताएं

शुरू करने से पहले, सुनिश्चित करें कि आपके पास हैं:

1. API access वाला एक Auth0 account
2. Auth0 में एक Machine-to-Machine application registered
3. M2M application को दी गई Management API permissions
4. API access वाला एक Brevo account
5. connector permissions वाला एक Tajo account

## प्रमाणीकरण

### Machine-to-Machine OAuth 2.0

```bash
# Auth0 Dashboard में एक M2M application बनाएं
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
// 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 डिफ़ॉल्ट रूप से 24 घंटे के लिए मान्य होता है
```

API Permissions

अपने M2M application को केवल आवश्यक scopes प्रदान करें: `read:users`, `read:user_idp_tokens`, `read:roles`, और `read:logs`. आवश्यकता न हो तो write permissions देने से बचें।

## कॉन्फ़िगरेशन

### बेसिक सेटअप

```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 * * *"  # हर 4 घंटे में

    lists:
      all_users: 20
      verified_users: 21
      social_login: 22
```

### Field Mapping

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

## API Endpoints

| Endpoint | Method | विवरण |
| --- | --- | --- |
| `https://{domain}/api/v2/users` | GET | users list या search करें |
| `https://{domain}/api/v2/users/{id}` | GET | एक user प्राप्त करें |
| `https://{domain}/api/v2/users/{id}` | PATCH | user metadata अपडेट करें |
| `https://{domain}/api/v2/users/{id}/roles` | GET | user roles प्राप्त करें |
| `https://{domain}/api/v2/roles` | GET | सभी roles list करें |
| `https://{domain}/api/v2/logs` | GET | log events प्राप्त करें |
| `https://{domain}/api/v2/stats/active-users` | GET | active users count प्राप्त करें |
| `https://{domain}/api/v2/stats/daily` | GET | daily stats प्राप्त करें |
| `https://{domain}/oauth/token` | POST | access token प्राप्त करें |

## कोड उदाहरण

### कनेक्टर शुरू करें

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

### Users को Brevo से Sync करें

```javascript
// Auth0 users के माध्यम से paginate करें
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;
}
```

### Log Streams के माध्यम से Authentication Events ट्रैक करें

```javascript
// Auth0 Log Stream webhook सेट करें
// Auth0 Dashboard > Monitoring > Streams में कॉन्फ़िगर करें

app.post('/webhooks/auth0', async (req, res) => {
  // 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':   // सफल 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':  // सफल signup
        await tajo.contacts.sync({
          email: log.data.details.email,
          attributes: { SIGNUP_DATE: log.data.date },
          listIds: [20]
        });
        break;
      case 'sp':  // सफल password change
        await tajo.events.track({
          email: log.data.details.email,
          event: 'password_changed'
        });
        break;
    }
  }

  res.status(200).send('OK');
});
```

### Role-आधारित Segmentation

```javascript
// segmentation के लिए user roles sync करें
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 Category | Limit | नोट्स |
| --- | --- | --- |
| Management API | 50 req/sec (Free) | प्रति tenant |
| Management API | 100 req/sec (Paid) | प्रति tenant |
| Authentication API | भिन्न | plan पर आधारित |
| Log Streams | Real-time | delivery पर कोई rate limit नहीं |
| Pagination | अधिकतम 50 items/page | `page` और `per_page` params का उपयोग करें |

Pagination आवश्यक

Auth0 Management API प्रति page अधिकतम 50 परिणाम लौटाता है। हमेशा `page` और `per_page` parameters का उपयोग करके pagination लागू करें। कुल count प्राप्त करने के लिए `include_totals=true` शामिल करें।

## समस्या निवारण

| समस्या | कारण | समाधान |
| --- | --- | --- |
| 401 Unauthorized | Token expire हो गया | नया M2M token request करें (24h expiry) |
| 403 Forbidden | गायब scopes | M2M app को आवश्यक permissions दें |
| खाली user list | Search query error | v3 engine के लिए Lucene query syntax का उपयोग करें |
| गायब metadata | Metadata सेट नहीं है | user\_metadata और app\_metadata की जांच करें |
| Rate limit 429 | बहुत अधिक requests | retry headers के साथ backoff लागू करें |

### Debug Mode

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

## सर्वोत्तम प्रथाएं

1. **Log Streams का उपयोग करें** - Logs API को poll करने के बजाय real-time event streaming
2. **Pagination लागू करें** - बड़े tenants के लिए हमेशा user list queries को paginate करें
3. **M2M tokens cache करें** - expiry के निकट तक tokens को reuse करें (24h डिफ़ॉल्ट lifetime)
4. **search engine v3 का उपयोग करें** - कुशल user searches के लिए Lucene query syntax का उपयोग करें
5. **केवल verified users sync करें** - unverified contacts से बचने के लिए `email_verified:true` पर filter करें
6. **user metadata का लाभ उठाएं** - sync के लिए Auth0 user\_metadata में custom attributes store करें

## सुरक्षा

- **Machine-to-Machine OAuth** - server-to-server auth के लिए client credentials grant
- **Scoped permissions** - न्यूनतम आवश्यक Management API scopes प्रदान करें
- **Token rotation** - M2M tokens डिफ़ॉल्ट रूप से 24 घंटे के बाद expire होते हैं
- **Log Stream auth** - webhook endpoints के लिए bearer token verification का उपयोग करें
- **Tenant isolation** - प्रति Auth0 tenant अलग configurations
- **Encrypted transport** - सभी API communications के लिए TLS 1.2+

## संबंधित संसाधन

- [Segment कनेक्टर](https://tajo.io/hi/docs/connectors/custom/segment)
- [Zapier कनेक्टर](https://tajo.io/hi/docs/connectors/custom/zapier)
- [Customer Sync Skill](https://tajo.io/hi/docs/skills/data-sync/customer-sync)
- [Auth0 Management API Documentation](https://auth0.com/docs/api/management/v2)