Quick Guide to Implementing Webhooks in SharpSpring

Aug 15, 2024 • 7 minute read

Hey there, fellow JavaScript dev! Ready to supercharge your SharpSpring integration with webhooks? Let's dive right in and get those real-time updates flowing!

Introduction

Webhooks are like the cool kids of API integrations - they notify you instantly when something happens in SharpSpring, no constant polling required. We'll be using SharpSpring's API to set these up, so buckle up for some code-heavy goodness!

Prerequisites

Before we start, make sure you've got:

A SharpSpring account with API access (you're not sneaking in without this!)
Node.js environment ready to roll
A solid grasp on RESTful APIs and webhooks (but hey, you're here, so I'm sure you're good!)

Setting Up SharpSpring API Access

First things first, let's get those API credentials. Head over to your SharpSpring account and grab your API key and secret. It's like getting the keys to the kingdom, but for data!

Here's a quick snippet to authenticate:

const axios = require('axios');

const apiKey = 'your_api_key';
const secretKey = 'your_secret_key';

const api = axios.create({
  baseURL: 'https://api.sharpspring.com/pubapi/v1/',
  params: { accountID: 'your_account_id' }
});

const authenticate = async () => {
  const response = await api.post('', {
    method: 'getAccessToken',
    params: { apiKey, secretKey }
  });
  return response.data.result.accessToken;
};

Creating a Webhook in SharpSpring

Now, let's create that webhook! We'll use the createWebhooks endpoint:

const createWebhook = async (accessToken) => {
  const response = await api.post('', {
    method: 'createWebhooks',
    params: {
      accessToken,
      webhooks: [{
        name: 'My Awesome Webhook',
        targetUrl: 'https://your-server.com/webhook',
        events: ['leadCreated', 'leadUpdated']
      }]
    }
  });
  return response.data.result;
};

Configuring Webhook Events

SharpSpring offers a buffet of events to choose from. In the example above, we're listening for leadCreated and leadUpdated. Feel free to add more to the events array - the more, the merrier!

Implementing the Webhook Endpoint

Time to set up our webhook receiver. Express.js to the rescue!

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

app.use(express.json());

app.post('/webhook', (req, res) => {
  console.log('Webhook received:', req.body);
  // Process the webhook data here
  res.sendStatus(200);
});

app.listen(3000, () => console.log('Webhook server running on port 3000'));

Verifying Webhook Requests

Trust, but verify! Let's add some security:

const crypto = require('crypto');

const verifyWebhook = (req, secretKey) => {
  const signature = req.headers['x-sharpspring-signature'];
  const hash = crypto.createHmac('sha256', secretKey)
    .update(JSON.stringify(req.body))
    .digest('hex');
  return signature === hash;
};

app.post('/webhook', (req, res) => {
  if (!verifyWebhook(req, 'your_webhook_secret')) {
    return res.sendStatus(401);
  }
  // Process verified webhook
});

Processing Webhook Data

Now, let's handle those events like a pro:

const handleWebhook = (event) => {
  switch (event.type) {
    case 'leadCreated':
      console.log('New lead:', event.data);
      break;
    case 'leadUpdated':
      console.log('Updated lead:', event.data);
      break;
    // Add more cases as needed
    default:
      console.log('Unhandled event type:', event.type);
  }
};

app.post('/webhook', (req, res) => {
  if (verifyWebhook(req, 'your_webhook_secret')) {
    handleWebhook(req.body);
    res.sendStatus(200);
  } else {
    res.sendStatus(401);
  }
});

Error Handling and Logging

Let's wrap our handler in a try-catch to keep things smooth:

app.post('/webhook', (req, res) => {
  try {
    if (verifyWebhook(req, 'your_webhook_secret')) {
      handleWebhook(req.body);
      res.sendStatus(200);
    } else {
      throw new Error('Invalid webhook signature');
    }
  } catch (error) {
    console.error('Webhook error:', error);
    res.sendStatus(error.message.includes('signature') ? 401 : 500);
  }
});

Testing Your Webhook Integration

Ready to test? Fire up ngrok to expose your local server:

ngrok http 3000

Use the ngrok URL as your webhook's targetUrl in SharpSpring, then trigger some events in your SharpSpring account. Watch those logs light up!

Conclusion

And there you have it! You've just implemented webhooks in SharpSpring like a boss. Your integration is now real-time, efficient, and ready to rock. Remember, this is just the beginning - feel free to expand and customize to your heart's content.

Additional Resources

Now go forth and webhook all the things! Happy coding! 🚀