Webhook Configuration

Webhooks allow Launchpad to notify your systems in real-time when events occur. Instead of repeatedly checking for updates, your application receives automatic notifications the moment something happens — like a new booking or payment.

What are webhooks?

A webhook is a way for one system to send data to another instantly:

Real-time notifications — receive updates as they happen
Push-based — Launchpad sends data to you
Event-driven — triggered by specific actions
Automated — no manual checking required

Think of it like a notification system for your software.

Why use webhooks?

Webhooks are useful when you need to:

React immediately — send SMS confirmations, trigger workflows
Keep systems in sync — update external databases instantly
Reduce API calls — no need to poll for changes
Build real-time features — live dashboards, instant alerts

How webhooks work

You create an endpoint (URL) on your server
You register that URL with Launchpad
When an event occurs, Launchpad sends data to your URL
Your server receives and processes the data

Before you start

You'll need:

A server that can receive HTTP POST requests
A publicly accessible URL (HTTPS required)
Owner or admin access in Launchpad
Technical knowledge or a developer to set up your endpoint

Creating a webhook

Go to Settings from the main menu
Click API or Developer Settings
Select the Webhooks tab
Click Add Webhook
Configure your webhook:

- URL — your endpoint address - Events — which events to subscribe to - Description — what this webhook is for

Click Create Webhook

Available events

Booking events

Event	Triggered when
`booking.created`	A new booking is made
`booking.updated`	Booking details change
`booking.cancelled`	A booking is cancelled
`booking.completed`	The experience has occurred

Payment events

Event	Triggered when
`payment.received`	A payment is processed
`payment.failed`	A payment attempt fails
`refund.processed`	A refund is completed

Customer events

Event	Triggered when
`customer.created`	A new customer is added
`customer.updated`	Customer details change

Product events

Event	Triggered when
`product.created`	A new product is added
`product.updated`	Product details change
`availability.changed`	Availability is modified

Webhook payload

Each webhook delivers a JSON payload:

{
  "event": "booking.created",
  "timestamp": "2024-03-15T10:30:00Z",
  "data": {
    "id": "book_abc123",
    "customer": {
      "id": "cust_xyz789",
      "name": "Jane Smith",
      "email": "[email protected]"
    },
    "product": {
      "id": "prod_456",
      "name": "Sunset Kayak Tour"
    },
    "date": "2024-03-20",
    "time": "17:00",
    "total": 150.00,
    "status": "confirmed"
  }
}

Payload structure

event — the event type that triggered this webhook
timestamp — when the event occurred (ISO 8601 format)
data — the relevant data for this event

Setting up your endpoint

Your endpoint must:

Accept HTTP POST requests
Be accessible via HTTPS
Return a 2xx status code on success
Respond within 30 seconds

Example endpoint (Node.js)

app.post('/webhooks/launchpad', (req, res) => {
  const event = req.body.event;
  const data = req.body.data;switch (event) {    case 'booking.created':      handleNewBooking(data);      break;    case 'payment.received':      handlePayment(data);      break;  }res.status(200).send('OK');});

Example endpoint (Python)

@app.route('/webhooks/launchpad', methods=['POST'])
def handle_webhook():
    payload = request.json
    event = payload.get('event')
    data = payload.get('data')if event == 'booking.created':        handle_new_booking(data)    elif event == 'payment.received':        handle_payment(data)return 'OK', 200

Verifying webhooks

Verify that webhooks come from Launchpad:

Signature verification

Each webhook includes a signature header:

X-Launchpad-Signature: sha256=abc123...

Verify this signature:

const crypto = require('crypto');function verifyWebhook(payload, signature, secret) {  const expected = crypto    .createHmac('sha256', secret)    .update(payload)    .digest('hex');return signature === sha256=${expected};}

Getting your webhook secret

Go to Settings > API > Webhooks
Find your webhook
Click View Secret
Use this secret for verification

Managing webhooks

Viewing webhooks

Go to Settings > API > Webhooks
See all configured webhooks
View status and recent deliveries

Editing a webhook

Find the webhook in your list
Click Edit
Update URL or events
Save changes

Testing a webhook

Find the webhook
Click Test
A sample event is sent to your endpoint
Check the response

Viewing delivery history

Click on a webhook
View recent deliveries
See status codes and response times
Debug failed deliveries

Disabling a webhook

Find the webhook
Toggle the Active switch off
Webhook stops receiving events

Deleting a webhook

Find the webhook
Click Delete
Confirm deletion

Handling failures

Retry policy

If your endpoint fails to respond:

Immediate retry — first retry after 1 minute
Second retry — after 5 minutes
Third retry — after 30 minutes
Fourth retry — after 2 hours
Fifth retry — after 24 hours

After 5 failures, the webhook is paused and you'll be notified.

What counts as failure

Timeout (no response in 30 seconds)
Non-2xx status code
Connection error
TLS/SSL errors

Re-enabling a paused webhook

Fix the underlying issue
Go to webhook settings
Click Re-enable
Test the webhook

Best practices

Endpoint design

Respond quickly — do heavy processing asynchronously
Return 200 immediately — even if you'll process later
Be idempotent — handle duplicate deliveries gracefully
Log everything — keep records for debugging

Example: Quick response with async processing

app.post('/webhooks/launchpad', async (req, res) => {
  // Immediately acknowledge receipt
  res.status(200).send('OK');// Process asynchronously  processWebhookAsync(req.body);});async function processWebhookAsync(payload) {  // Do the actual work here}

Security

Always verify signatures — don't trust unsigned webhooks
Use HTTPS — protect data in transit
Validate data — don't blindly trust the payload
Limit access — restrict who can configure webhooks

Handling duplicates

Webhooks may occasionally be delivered more than once:

Store the event ID when you process it
Check if you've seen this ID before
Skip processing if it's a duplicate

const processedEvents = new Set();function handleWebhook(payload) {  if (processedEvents.has(payload.id)) {    return; // Already processed  }processedEvents.add(payload.id);  // Process the event}

Troubleshooting

Webhook not triggering

Check the webhook is active
Verify you're subscribed to the correct events
Confirm the event actually occurred in Launchpad
Review webhook delivery history

Endpoint returning errors

Check your server logs
Verify the endpoint URL is correct
Ensure your server is running
Test the endpoint directly

Signature verification failing

Check you're using the correct secret
Verify you're hashing the raw request body
Ensure the signature header is being read correctly
Check for encoding issues

Timeouts

Reduce processing time in your endpoint
Move heavy work to async processing
Check your server isn't overloaded
Consider increasing server resources

Webhooks enable real-time integrations that react instantly — perfect for keeping your systems synchronised and your customers informed.