HubSpot Webhooks: CRM Integration Patterns

const axios = require('axios');

async function createWebhookSubscription(appId, accessToken) {
  const subscriptions = [
    {
      subscriptionType: 'contact.creation',
      propertyName: null,
      active: true
    },
    {
      subscriptionType: 'contact.propertyChange',
      propertyName: 'email',
      active: true
    },
    {
      subscriptionType: 'deal.propertyChange',
      propertyName: 'dealstage',
      active: true
    }
  ];

  for (const subscription of subscriptions) {
    await axios.post(
      `https://api.hubapi.com/webhooks/v3/${appId}/subscriptions`,
      subscription,
      {
        headers: {
          'Authorization': `Bearer ${accessToken}`,
          'Content-Type': 'application/json'
        }
      }
    );
  }
}

const express = require('express');
const crypto = require('crypto');

const app = express();
app.use(express.json());

const CLIENT_SECRET = process.env.HUBSPOT_CLIENT_SECRET;

app.post('/webhooks/hubspot', async (req, res) => {
  // HubSpot expects a response within 5 seconds
  res.status(200).send('OK');

  // Process events asynchronously
  processHubSpotEvents(req.body).catch(err => {
    console.error('Event processing failed:', err);
  });
});

async function processHubSpotEvents(events) {
  for (const event of events) {
    switch (event.subscriptionType) {
      case 'contact.creation':
        await handleNewContact(event);
        break;
      case 'contact.propertyChange':
        await handleContactUpdate(event);
        break;
      case 'deal.propertyChange':
        await handleDealChange(event);
        break;
      default:
        console.log('Unhandled event type:', event.subscriptionType);
    }
  }
}

function verifyHubSpotSignature(req) {
  const signature = req.headers['x-hubspot-signature-v3'];
  const timestamp = req.headers['x-hubspot-request-timestamp'];

  // Reject requests older than 5 minutes
  const currentTime = Date.now();
  if (currentTime - parseInt(timestamp) > 300000) {
    throw new Error('Request timestamp too old');
  }

  // Build the signature base string
  const requestBody = JSON.stringify(req.body);
  const uri = `https://${req.headers.host}${req.originalUrl}`;
  const signatureBaseString = `${req.method}${uri}${requestBody}${timestamp}`;

  // Calculate expected signature
  const expectedSignature = crypto
    .createHmac('sha256', CLIENT_SECRET)
    .update(signatureBaseString)
    .digest('base64');

  if (signature !== expectedSignature) {
    throw new Error('Invalid signature');
  }

  return true;
}

// Middleware for signature verification
function hubspotSignatureMiddleware(req, res, next) {
  try {
    verifyHubSpotSignature(req);
    next();
  } catch (error) {
    console.error('Signature verification failed:', error.message);
    res.status(401).send('Unauthorized');
  }
}

app.post('/webhooks/hubspot', hubspotSignatureMiddleware, async (req, res) => {
  // Handler code here
});

async function handleNewContact(event) {
  const contactId = event.objectId;

  // Fetch full contact details from HubSpot API
  const contact = await hubspotClient.crm.contacts.basicApi.getById(
    contactId,
    ['email', 'firstname', 'lastname', 'company', 'phone']
  );

  // Sync to your external system
  await externalCRM.createLead({
    email: contact.properties.email,
    name: `${contact.properties.firstname} ${contact.properties.lastname}`,
    company: contact.properties.company,
    source: 'hubspot',
    hubspotId: contactId
  });
}

async function handleDealChange(event) {
  if (event.propertyName !== 'dealstage') return;

  const dealId = event.objectId;
  const newStage = event.propertyValue;

  // Fetch deal details
  const deal = await hubspotClient.crm.deals.basicApi.getById(
    dealId,
    ['dealname', 'amount', 'hubspot_owner_id'],
    undefined,
    ['contacts']
  );

  // Stage-specific actions
  switch (newStage) {
    case 'qualifiedtobuy':
      await notifySalesTeam(deal);
      break;
    case 'closedwon':
      await triggerOnboarding(deal);
      await updateRevenueMetrics(deal);
      break;
    case 'closedlost':
      await logLostDealAnalytics(deal);
      break;
  }
}

async function handleContactUpdate(event) {
  const contactId = event.objectId;
  const propertyName = event.propertyName;
  const newValue = event.propertyValue;

  // Trigger campaigns based on lifecycle stage changes
  if (propertyName === 'lifecyclestage' && newValue === 'customer') {
    await marketingPlatform.enrollInCampaign(contactId, 'customer-onboarding');
  }

  // Update email preferences in external ESP
  if (propertyName === 'email') {
    await emailServiceProvider.updateSubscriber({
      oldEmail: event.propertyValueBefore,
      newEmail: newValue,
      hubspotId: contactId
    });
  }
}

async function processHubSpotEvents(events) {
  // Group events by type for batch processing
  const eventsByType = events.reduce((acc, event) => {
    const type = event.subscriptionType;
    if (!acc[type]) acc[type] = [];
    acc[type].push(event);
    return acc;
  }, {});

  // Process each type in parallel
  const processors = Object.entries(eventsByType).map(([type, typeEvents]) => {
    return processBatchByType(type, typeEvents);
  });

  await Promise.all(processors);
}

async function processBatchByType(type, events) {
  // Fetch all records in one batch API call
  const records = await hubspotClient.crm.contacts.batchApi.read({
    inputs: events.map(e => ({ id: e.objectId })),
    properties: ['email', 'firstname', 'lastname']
  });

  for (const record of records.results) {
    await processRecord(type, record);
  }
}

const processedEvents = new Set(); // Use Redis in production

async function processEventWithDeduplication(event) {
  const eventKey = `${event.eventId}-${event.subscriptionType}`;

  if (processedEvents.has(eventKey)) {
    console.log('Skipping duplicate event:', eventKey);
    return;
  }

  processedEvents.add(eventKey);
  await processEvent(event);
}