---
title: "इवेंट टाइप्स संदर्भ"
description: "Tajo लॉयल्टी प्लेटफ़ॉर्म इंटीग्रेशन उदाहरणों के साथ सभी Brevo वेबहुक इवेंट टाइप्स के लिए पूर्ण संदर्भ गाइड"
url: https://tajo.io/hi/docs/webhooks-events/event-types/
markdown: https://tajo.io/hi/docs/webhooks-events/event-types.md
lang: hi-IN
robots: noindex
---

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

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

# इवेंट टाइप्स संदर्भ

यह व्यापक संदर्भ Brevo में उपलब्ध सभी वेबहुक इवेंट टाइप्स को कवर करता है, जिसमें Tajo लॉयल्टी प्लेटफ़ॉर्म इंटीग्रेशन के लिए विशिष्ट उदाहरण शामिल हैं.

## ईमेल इवेंट्स

### delivered

तब ट्रिगर होता है जब कोई ईमेल प्राप्तकर्ता के मेलबॉक्स में सफलतापूर्वक डिलीवर हो जाता है.

**पेलोड उदाहरण:**

```json
{
  "event": "delivered",
  "email": "customer@example.com",
  "id": 123456,
  "date": "2024-01-25 14:30:00",
  "ts": 1640995200,
  "message-id": "<202401251430.123456@mail.brevo.com>",
  "template_id": 101,
  "tags": ["loyalty", "points-earned"],
  "sending_ip": "185.107.232.1",
  "event_id": "evt_abc123"
}
```

**Tajo इंटीग्रेशन के उपयोग के मामले:**

- ग्राहक प्रोफ़ाइल में डिलीवरी सफलता दर अपडेट करें
- लॉयल्टी कैम्पेन के लिए फ़ॉलो-अप कार्रवाइयां ट्रिगर करें
- टियर के अनुसार ईमेल डिलीवरी प्रदर्शन ट्रैक करें

```javascript
async function handleEmailDelivered(event) {
  const customer = await loyaltyService.getCustomer(event.email);

  // Update delivery stats
  await loyaltyService.updateEngagement(event.email, {
    emailsDelivered: customer.emailsDelivered + 1,
    lastEmailDelivered: new Date(event.date),
    deliveryRate: calculateDeliveryRate(customer)
  });

  // Track loyalty campaign delivery
  if (event.tags.includes('loyalty')) {
    await loyaltyService.trackCampaignMetric('loyalty_email_delivered', {
      email: event.email,
      template_id: event.template_id,
      tier: customer.loyaltyTier
    });
  }
}
```

### opened

तब ट्रिगर होता है जब कोई प्राप्तकर्ता ईमेल खोलता है (पिक्सेल लोडिंग को ट्रैक करता है).

**पेलोड उदाहरण:**

```json
{
  "event": "opened",
  "email": "customer@example.com",
  "date": "2024-01-25 15:45:00",
  "ts": 1641000300,
  "message-id": "<202401251430.123456@mail.brevo.com>",
  "template_id": 101,
  "tags": ["loyalty", "tier-upgrade"],
  "user-agent": "Mozilla/5.0 (iPhone; CPU iPhone OS 17_0 like Mac OS X)",
  "geo": {
    "country": "US",
    "region": "CA",
    "city": "San Francisco"
  }
}
```

**Tajo इंटीग्रेशन के उपयोग के मामले:**

- ग्राहक एंगेजमेंट स्कोर बढ़ाएं
- लॉयल्टी कैम्पेन की प्रभावशीलता ट्रैक करें
- व्यवहार-आधारित रिवॉर्ड ट्रिगर करें
- भविष्य के कम्युनिकेशन को पर्सनलाइज़ करें

```javascript
async function handleEmailOpened(event) {
  const customer = await loyaltyService.getCustomer(event.email);

  // Significant engagement - boost score
  await loyaltyService.updateEngagement(event.email, {
    emailsOpened: customer.emailsOpened + 1,
    lastEmailOpened: new Date(event.date),
    engagementScore: customer.engagementScore + 5,
    preferredDevice: getDeviceType(event['user-agent'])
  });

  // Reward engagement for loyalty members
  if (event.tags.includes('loyalty') && customer.loyaltyTier) {
    await loyaltyService.awardEngagementBonus(event.email, {
      type: 'email_engagement',
      points: getEngagementPoints(customer.loyaltyTier),
      reason: 'Email opened'
    });
  }

  // Track timing patterns for optimization
  await loyaltyService.recordEngagementTime(event.email, {
    campaign: event.template_id,
    openTime: new Date(event.date),
    timezone: getTimezone(event.geo)
  });
}
```

### clicked

तब ट्रिगर होता है जब कोई प्राप्तकर्ता ईमेल में किसी लिंक पर क्लिक करता है.

**पेलोड उदाहरण:**

```json
{
  "event": "clicked",
  "email": "customer@example.com",
  "date": "2024-01-25 16:20:00",
  "ts": 1641002400,
  "message-id": "<202401251430.123456@mail.brevo.com>",
  "template_id": 101,
  "tags": ["loyalty", "rewards-reminder"],
  "link": "https://yourdomain.com/rewards?utm_source=brevo&utm_campaign=loyalty",
  "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"
}
```

**Tajo इंटीग्रेशन के उपयोग के मामले:**

- कन्वर्शन फ़नल का प्रदर्शन ट्रैक करें
- क्लिक-थ्रू बोनस प्रदान करें
- उच्च-मूल्य वाले कंटेंट की पहचान करें
- ईमेल से वेबसाइट तक के फ़्लो को ऑप्टिमाइज़ करें

```javascript
async function handleEmailClicked(event) {
  const customer = await loyaltyService.getCustomer(event.email);
  const clickedUrl = new URL(event.link);

  // High-value engagement
  await loyaltyService.updateEngagement(event.email, {
    emailsClicked: customer.emailsClicked + 1,
    lastEmailClicked: new Date(event.date),
    engagementScore: customer.engagementScore + 15,
    clickThroughRate: calculateCTR(customer)
  });

  // Track specific link types
  if (clickedUrl.pathname.includes('/rewards')) {
    await loyaltyService.trackEvent(event.email, 'Rewards Page Clicked', {
      source: 'email',
      campaign: event.template_id,
      utm_campaign: clickedUrl.searchParams.get('utm_campaign')
    });

    // Award exploration bonus
    await loyaltyService.awardEngagementBonus(event.email, {
      type: 'rewards_exploration',
      points: 10,
      reason: 'Clicked rewards link'
    });
  }

  // Track product interest
  if (clickedUrl.pathname.includes('/products')) {
    const productId = extractProductId(clickedUrl);
    await loyaltyService.trackProductInterest(event.email, productId, {
      source: 'email_click',
      timestamp: new Date(event.date)
    });
  }
}
```

### bounced / hard\_bounced

तब ट्रिगर होता है जब कोई ईमेल बाउंस होता है (अस्थायी विफलता) या हार्ड बाउंस होता है (स्थायी विफलता).

**पेलोड उदाहरण:**

```json
{
  "event": "hard_bounced",
  "email": "invalid@example.com",
  "date": "2024-01-25 14:35:00",
  "ts": 1640995500,
  "message-id": "<202401251430.123456@mail.brevo.com>",
  "template_id": 101,
  "tags": ["loyalty"],
  "reason": "550 5.1.1 User unknown",
  "bounce_type": "hard"
}
```

**Tajo इंटीग्रेशन के उपयोग के मामले:**

- ईमेल वैधता स्थिति अपडेट करें
- वैकल्पिक कम्युनिकेशन चैनलों पर स्विच करें
- ग्राहक डेटाबेस साफ़ करें
- अमान्य पतों पर आगे भेजना रोकें

```javascript
async function handleEmailBounced(event) {
  const isHardBounce = event.event === 'hard_bounced' || event.bounce_type === 'hard';

  if (isHardBounce) {
    // Permanent failure - mark email as invalid
    await loyaltyService.updateCustomerStatus(event.email, {
      emailStatus: 'invalid',
      emailBounced: true,
      bounceReason: event.reason,
      lastBounce: new Date(event.date),
      communicationPreference: 'sms' // Switch to SMS if available
    });

    // Remove from email marketing lists
    await loyaltyService.removeFromEmailMarketing(event.email);

    // Suggest phone verification
    const customer = await loyaltyService.getCustomer(event.email);
    if (customer?.phone) {
      await loyaltyService.suggestPhoneVerification(customer.phone);
    }

  } else {
    // Soft bounce - temporary issue
    await loyaltyService.updateEngagement(event.email, {
      softBounceCount: customer.softBounceCount + 1,
      lastSoftBounce: new Date(event.date)
    });

    // Retry logic for soft bounces
    if (customer.softBounceCount < 5) {
      await loyaltyService.scheduleEmailRetry(event.email, event.template_id);
    }
  }
}
```

### spam

तब ट्रिगर होता है जब कोई प्राप्तकर्ता किसी ईमेल को स्पैम के रूप में चिह्नित करता है.

**पेलोड उदाहरण:**

```json
{
  "event": "spam",
  "email": "customer@example.com",
  "date": "2024-01-25 17:10:00",
  "ts": 1641005400,
  "message-id": "<202401251430.123456@mail.brevo.com>",
  "template_id": 101,
  "tags": ["loyalty", "promotional"]
}
```

**Tajo इंटीग्रेशन के उपयोग के मामले:**

- ईमेल कम्युनिकेशन तुरंत बंद करें
- ईमेल कंटेंट की समीक्षा करें और उसे बेहतर बनाएं
- सेगमेंट के अनुसार स्पैम पैटर्न का विश्लेषण करें
- सख़्त ऑप्ट-इन प्रक्रियाएं लागू करें

```javascript
async function handleEmailSpam(event) {
  // Immediately disable email marketing
  await loyaltyService.updateCustomerPreferences(event.email, {
    emailMarketing: false,
    marketingEnabled: false,
    spamReported: true,
    spamReportDate: new Date(event.date)
  });

  // Alert marketing team for review
  await loyaltyService.alertMarketing('spam_complaint', {
    email: event.email,
    template: event.template_id,
    campaign_tags: event.tags,
    severity: 'high'
  });

  // Analyze spam patterns
  await loyaltyService.analyzeSpamPattern({
    template_id: event.template_id,
    tags: event.tags,
    customer_segment: await loyaltyService.getCustomerSegment(event.email)
  });

  // Consider account review if multiple spam reports
  const customer = await loyaltyService.getCustomer(event.email);
  if (customer.spamReports > 2) {
    await loyaltyService.flagForReview(event.email, 'multiple_spam_reports');
  }
}
```

## SMS इवेंट्स

### sms\_delivered

तब ट्रिगर होता है जब कोई SMS प्राप्तकर्ता के फ़ोन पर सफलतापूर्वक डिलीवर हो जाता है.

**पेलोड उदाहरण:**

```json
{
  "event": "sms_delivered",
  "phone": "+1234567890",
  "date": "2024-01-25 14:45:00",
  "ts": 1640996700,
  "message-id": "sms_abc123",
  "tags": ["loyalty", "points-alert"],
  "sender": "TAJO",
  "content": "🎉 Great news! You earned 150 points from your recent purchase. Total: 1,250 points."
}
```

**Tajo इंटीग्रेशन के उपयोग के मामले:**

- सफल SMS डिलीवरी की पुष्टि करें
- SMS एंगेजमेंट दरें ट्रैक करें
- फ़ोन नंबर की सटीकता सत्यापित करें
- कैरियर डिलीवरी प्रदर्शन पर नज़र रखें

```javascript
async function handleSMSDelivered(event) {
  const customer = await loyaltyService.getCustomerByPhone(event.phone);

  await loyaltyService.updateEngagement(customer.email, {
    smsDelivered: customer.smsDelivered + 1,
    lastSMSDelivered: new Date(event.date),
    smsDeliveryRate: calculateSMSDeliveryRate(customer),
    phoneStatus: 'valid'
  });

  // Track loyalty SMS performance
  if (event.tags.includes('loyalty')) {
    await loyaltyService.trackCampaignMetric('loyalty_sms_delivered', {
      phone: event.phone,
      content_type: getSMSContentType(event.content),
      customer_tier: customer.loyaltyTier
    });
  }
}
```

### sms\_failed

तब ट्रिगर होता है जब SMS डिलीवरी विफल हो जाती है.

**पेलोड उदाहरण:**

```json
{
  "event": "sms_failed",
  "phone": "+1234567890",
  "date": "2024-01-25 14:32:00",
  "ts": 1640996320,
  "message-id": "sms_def456",
  "tags": ["loyalty", "urgent"],
  "sender": "TAJO",
  "reason": "Invalid phone number format",
  "error_code": "30006"
}
```

**Tajo इंटीग्रेशन के उपयोग के मामले:**

- फ़ोन नंबर की वैधता अपडेट करें
- ईमेल नोटिफ़िकेशन पर स्विच करें
- फ़ोन नंबर डेटाबेस साफ़ करें
- मैन्युअल सत्यापन के लिए कस्टमर सर्विस को सूचित करें

```javascript
async function handleSMSFailed(event) {
  const customer = await loyaltyService.getCustomerByPhone(event.phone);

  await loyaltyService.updateCustomerStatus(customer.email, {
    phoneStatus: 'invalid',
    smsEnabled: false,
    smsFailureReason: event.reason,
    lastSMSFailure: new Date(event.date),
    communicationPreference: 'email'
  });

  // For urgent loyalty notifications, fall back to email
  if (event.tags.includes('urgent') || event.tags.includes('loyalty')) {
    await loyaltyService.sendEmailFallback(customer.email, {
      originalSMS: event.content,
      reason: 'SMS delivery failed'
    });
  }

  // Flag for phone number verification
  await loyaltyService.flagForPhoneVerification(customer.email);
}
```

### sms\_reply

तब ट्रिगर होता है जब कोई प्राप्तकर्ता किसी SMS का उत्तर देता है.

**पेलोड उदाहरण:**

```json
{
  "event": "sms_reply",
  "phone": "+1234567890",
  "date": "2024-01-25 15:20:00",
  "ts": 1641000000,
  "message-id": "sms_reply_123",
  "text": "BALANCE",
  "original_message_id": "sms_abc123"
}
```

**Tajo इंटीग्रेशन के उपयोग के मामले:**

- लॉयल्टी प्रोग्राम कमांड प्रोसेस करें
- कस्टमर सर्विस अनुरोधों को संभालें
- कम्युनिकेशन प्राथमिकताएं अपडेट करें
- स्वचालित उत्तर ट्रिगर करें

```javascript
async function handleSMSReply(event) {
  const customer = await loyaltyService.getCustomerByPhone(event.phone);
  const replyText = event.text.toUpperCase().trim();

  // High engagement - customer actively participating
  await loyaltyService.updateEngagement(customer.email, {
    smsReplies: customer.smsReplies + 1,
    lastSMSReply: new Date(event.date),
    engagementScore: customer.engagementScore + 10
  });

  // Process loyalty commands
  switch (replyText) {
    case 'BALANCE':
      await loyaltyService.sendPointsBalance(event.phone);
      break;

    case 'REWARDS':
      await loyaltyService.sendAvailableRewards(event.phone, customer.loyaltyTier);
      break;

    case 'TIER':
      await loyaltyService.sendTierInfo(event.phone, customer);
      break;

    case 'HELP':
      await loyaltyService.sendSMSHelp(event.phone);
      break;

    case 'STOP':
    case 'UNSUBSCRIBE':
      await loyaltyService.unsubscribeFromSMS(event.phone);
      break;

    default:
      // Forward to customer service
      await loyaltyService.forwardToSupport(customer.email, {
        channel: 'sms',
        message: event.text,
        timestamp: new Date(event.date)
      });
  }
}
```

## कॉन्टैक्ट इवेंट्स

### contact\_created

तब ट्रिगर होता है जब Brevo में कोई नया कॉन्टैक्ट जोड़ा जाता है.

**पेलोड उदाहरण:**

```json
{
  "event": "contact_created",
  "email": "newcustomer@example.com",
  "date": "2024-01-25 13:15:00",
  "ts": 1640992500,
  "attributes": {
    "FIRSTNAME": "John",
    "LASTNAME": "Doe",
    "LOYALTY_ID": "LYL-2024-001",
    "LOYALTY_TIER": "Bronze",
    "LOYALTY_POINTS": 0
  },
  "lists": [1, 5]
}
```

**Tajo इंटीग्रेशन के उपयोग के मामले:**

- वेलकम कैम्पेन ट्रिगर करें
- लॉयल्टी प्रोग्राम में एनरोलमेंट सेट अप करें
- ग्राहक यात्रा शुरू करें
- साइन अप बोनस प्रदान करें

```javascript
async function handleContactCreated(event) {
  const isLoyaltyMember = event.attributes?.LOYALTY_ID;

  if (isLoyaltyMember) {
    // New loyalty member - trigger welcome flow
    await loyaltyService.triggerWelcomeFlow(event.email, {
      loyaltyId: event.attributes.LOYALTY_ID,
      tier: event.attributes.LOYALTY_TIER || 'Bronze',
      signupBonus: 500
    });

    // Award signup bonus
    await loyaltyService.awardPoints(event.email, {
      amount: 500,
      reason: 'Welcome bonus',
      type: 'signup_bonus'
    });

    // Schedule onboarding emails
    await loyaltyService.scheduleOnboardingSequence(event.email, {
      tier: event.attributes.LOYALTY_TIER,
      preferences: event.attributes
    });
  }

  // Track signup source
  await loyaltyService.trackSignupSource(event.email, {
    lists: event.lists,
    attributes: event.attributes,
    timestamp: new Date(event.date)
  });
}
```

### contact\_updated

तब ट्रिगर होता है जब कॉन्टैक्ट की जानकारी अपडेट होती है.

**पेलोड उदाहरण:**

```json
{
  "event": "contact_updated",
  "email": "customer@example.com",
  "date": "2024-01-25 16:45:00",
  "ts": 1641003900,
  "updated_attributes": {
    "LOYALTY_POINTS": 1250,
    "LOYALTY_TIER": "Silver",
    "TOTAL_SPENT": 899.99
  },
  "previous_attributes": {
    "LOYALTY_POINTS": 750,
    "LOYALTY_TIER": "Bronze",
    "TOTAL_SPENT": 549.99
  }
}
```

**Tajo इंटीग्रेशन के उपयोग के मामले:**

- टियर अपग्रेड का पता लगाएं
- पॉइंट बैलेंस में बदलाव ट्रैक करें
- प्रोफ़ाइल की पूर्णता पर नज़र रखें
- टियर-विशिष्ट कैम्पेन ट्रिगर करें

```javascript
async function handleContactUpdated(event) {
  const updated = event.updated_attributes;
  const previous = event.previous_attributes;

  // Check for tier upgrade
  if (updated.LOYALTY_TIER && updated.LOYALTY_TIER !== previous.LOYALTY_TIER) {
    await loyaltyService.handleTierUpgrade(event.email, {
      previousTier: previous.LOYALTY_TIER,
      newTier: updated.LOYALTY_TIER,
      pointsBalance: updated.LOYALTY_POINTS
    });

    // Send congratulations
    await loyaltyService.sendTierUpgradeEmail(event.email, {
      newTier: updated.LOYALTY_TIER,
      benefits: loyaltyService.getTierBenefits(updated.LOYALTY_TIER)
    });
  }

  // Track significant point increases
  const pointIncrease = updated.LOYALTY_POINTS - previous.LOYALTY_POINTS;
  if (pointIncrease > 0) {
    await loyaltyService.trackPointsEarned(event.email, {
      amount: pointIncrease,
      newTotal: updated.LOYALTY_POINTS,
      source: 'profile_update'
    });
  }

  // Monitor spending milestones
  if (updated.TOTAL_SPENT > previous.TOTAL_SPENT) {
    await loyaltyService.checkSpendingMilestones(event.email, {
      currentSpend: updated.TOTAL_SPENT,
      previousSpend: previous.TOTAL_SPENT
    });
  }
}
```

## इवेंट प्रोसेसिंग के सर्वोत्तम तरीके

### 1. आइडेम्पोटेंसी हैंडलिंग

```javascript
class WebhookProcessor {
  constructor() {
    this.processedEvents = new Set();
  }

  async processEvent(event) {
    const eventKey = `${event.event}_${event.email}_${event.ts}`;

    if (this.processedEvents.has(eventKey)) {
      console.log('Duplicate event ignored:', eventKey);
      return;
    }

    this.processedEvents.add(eventKey);

    try {
      await this.handleEvent(event);
    } catch (error) {
      this.processedEvents.delete(eventKey); // Allow retry
      throw error;
    }
  }
}
```

### 2. इवेंट सीक्वेंसिंग

```javascript
async function processEventInSequence(event) {
  const customer = await loyaltyService.getCustomer(event.email);
  const lastProcessedTime = customer.lastWebhookProcessed || 0;

  // Ensure events are processed in chronological order
  if (event.ts < lastProcessedTime) {
    console.warn('Out-of-order event received, queuing for later processing');
    await loyaltyService.queueEventForLaterProcessing(event);
    return;
  }

  await handleWebhookEvent(event);

  // Update last processed timestamp
  await loyaltyService.updateCustomer(event.email, {
    lastWebhookProcessed: event.ts
  });
}
```

### 3. बैच प्रोसेसिंग

```javascript
class BatchEventProcessor {
  constructor() {
    this.eventBatch = [];
    this.batchSize = 100;
    this.flushInterval = 5000; // 5 seconds

    setInterval(() => this.flushBatch(), this.flushInterval);
  }

  addEvent(event) {
    this.eventBatch.push(event);

    if (this.eventBatch.length >= this.batchSize) {
      this.flushBatch();
    }
  }

  async flushBatch() {
    if (this.eventBatch.length === 0) return;

    const batch = this.eventBatch.splice(0);

    try {
      await loyaltyService.processBatchEvents(batch);
    } catch (error) {
      console.error('Batch processing failed:', error);
      // Re-queue failed events
      this.eventBatch.unshift(...batch);
    }
  }
}
```

## अगले कदम

- **वेबहुक सुरक्षा गाइड** - सुरक्षा के सर्वोत्तम तरीके
- **[वेबहुक की टेस्टिंग](https://tajo.io/hi/docs/testing-debug/)** - टेस्टिंग और डीबगिंग
- **वेबहुक एनालिटिक्स** - प्रदर्शन की निगरानी
- **[प्लेटफ़ॉर्म इंटीग्रेशन](https://tajo.io/hi/docs/platform-integration/tajo-brevo-integration)** - पूरी इंटीग्रेशन गाइड