Event Types

async function handleEmailOpened(data) {
  const { emailId, to } = data;

  await db.emails.update({
    where: { id: emailId },
    data: {
      opened: true,
      openedAt: new Date(),
      opens: { increment: 1 },
    },
  });

  await db.contacts.update({
    where: { email: to.email },
    data: {
      lastEngagement: new Date(),
      engagementScore: { increment: 1 },
    },
  });
}

async function handleEmailClicked(data) {
  const { emailId, to, clickedUrl } = data;

  await db.clicks.create({
    data: {
      emailId,
      recipientEmail: to.email,
      url: clickedUrl,
      clickedAt: new Date(),
    },
  });

  await db.contacts.update({
    where: { email: to.email },
    data: {
      lastEngagement: new Date(),
      engagementScore: { increment: 5 },
    },
  });
}

async function handleEmailBounced(data) {
  const { to, bounceType, reason } = data;

  if (bounceType === 'Permanent') {
    // Remove from active mailing lists
    await db.contacts.update({
      where: { email: to.email },
      data: {
        status: 'bounced',
        bouncedAt: new Date(),
        bounceReason: reason,
      },
    });

    // Suppress future emails
    await db.suppressions.create({
      data: {
        email: to.email,
        type: 'bounce',
        reason: reason,
      },
    });

    // Alert team
    await sendAlert(`Hard bounce for ${to.email}: ${reason}`);
  }
}

async function handleSpamReport(data) {
  const { to } = data;
  const email = to.email;

  // Immediately suppress the email
  await db.suppressions.create({
    data: {
      email,
      type: 'complaint',
      reportedAt: new Date(),
    },
  });

  // Update contact status
  await db.contacts.update({
    where: { email },
    data: {
      status: 'complained',
      complainedAt: new Date(),
    },
  });

  // Alert team for reputation monitoring
  await sendAlert(`Spam complaint from ${email}`);
}

async function handleGlobalUnsubscribe(data) {
  const { emailId, campaignId } = data;

  // Update email activity record
  await db.emails.update({
    where: { id: emailId },
    data: {
      unsubscribed: true,
      unsubscribedAt: new Date(),
    },
  });

  console.log(
    `Global unsubscribe from email ${emailId}, campaign ${campaignId}`
  );
}

async function handleGroupUnsubscribe(data) {
  const { emailId, unsubscribeGroupId, campaignId } = data;

  // Update email activity record
  await db.emails.update({
    where: { id: emailId },
    data: {
      groupUnsubscribed: true,
      unsubscribeGroupId,
      unsubscribedAt: new Date(),
    },
  });

  console.log(
    `Group unsubscribe from email ${emailId}, group ${unsubscribeGroupId}`
  );
}

async function handleGroupResubscribe(data) {
  const { emailId, unsubscribeGroupId } = data;

  // Update subscription record
  await db.emails.update({
    where: { id: emailId },
    data: {
      resubscribed: true,
      resubscribeGroupId: unsubscribeGroupId,
      resubscribedAt: new Date(),
    },
  });

  console.log(
    `Group resubscribe for email ${emailId}, group ${unsubscribeGroupId}`
  );
}

async function handleContactCreated(data) {
  const { contactId, email, name } = data;

  // Sync to CRM
  await crm.contacts.create({
    externalId: contactId,
    email,
    name,
    createdAt: new Date(),
  });
}

async function handleContactUpdated(data) {
  const { contactId, email, name, changedFields } = data;

  // Sync to CRM
  await crm.contacts.update({
    externalId: contactId,
    email,
    name,
    changedFields,
    updatedAt: new Date(),
  });
}

async function handleContactDeleted(data) {
  const { contactId, email } = data;

  // Remove from CRM
  await crm.contacts.delete({
    externalId: contactId,
  });

  console.log(`Contact ${email} removed from CRM`);
}

curl -X GET https://api.autosend.com/v1/webhooks/events/available \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "x-project-id: YOUR_PROJECT_ID"

const fetch = require('node-fetch');

const API_KEY = process.env.AUTOSEND_API_KEY;
const PROJECT_ID = process.env.AUTOSEND_PROJECT_ID;

async function getAvailableEvents() {
  const response = await fetch(
    'https://api.autosend.com/v1/webhooks/events/available',
    {
      method: 'GET',
      headers: {
        Authorization: `Bearer ${API_KEY}`,
        'x-project-id': PROJECT_ID,
      },
    }
  );

  const data = await response.json();
  console.log(data);
  return data;
}

getAvailableEvents();

import requests
import os

API_KEY = os.environ.get('AUTOSEND_API_KEY')
PROJECT_ID = os.environ.get('AUTOSEND_PROJECT_ID')

def get_available_events():
    url = 'https://api.autosend.com/v1/webhooks/events/available'
    headers = {
        'Authorization': f'Bearer {API_KEY}',
        'x-project-id': PROJECT_ID
    }

    response = requests.get(url, headers=headers)
    data = response.json()
    print(data)
    return data

get_available_events()

<?php

$apiKey = getenv('AUTOSEND_API_KEY');
$projectId = getenv('AUTOSEND_PROJECT_ID');

$ch = curl_init('https://api.autosend.com/v1/webhooks/events/available');

curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer ' . $apiKey,
    'x-project-id: ' . $projectId
]);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

$response = curl_exec($ch);
$data = json_decode($response, true);
curl_close($ch);

print_r($data);
?>

package main

import (
    "fmt"
    "io"
    "net/http"
    "os"
)

func main() {
    apiKey := os.Getenv("AUTOSEND_API_KEY")
    projectId := os.Getenv("AUTOSEND_PROJECT_ID")

    req, _ := http.NewRequest("GET", "https://api.autosend.com/v1/webhooks/events/available", nil)
    req.Header.Set("Authorization", "Bearer "+apiKey)
    req.Header.Set("x-project-id", projectId)

    client := &http.Client{}
    resp, _ := client.Do(req)
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    fmt.Println(string(body))
}

require 'net/http'
require 'json'
require 'uri'

api_key = ENV['AUTOSEND_API_KEY']
project_id = ENV['AUTOSEND_PROJECT_ID']

uri = URI('https://api.autosend.com/v1/webhooks/events/available')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Get.new(uri)
request['Authorization'] = "Bearer #{api_key}"
request['x-project-id'] = project_id

response = http.request(request)
data = JSON.parse(response.body)
puts data