Integrations & Automation 11 min read

How to Connect Booking Events to Your CRM with Webhooks

Every new booking, cancellation, reschedule and completion can be pushed to your CRM, accounting tool, spreadsheet or chat in real time — automatically. This guide shows you how to wire up Clickobook bookings to Zapier, n8n, Make and Pabbly Connect using webhooks, no code required.

You run a service business, customers book online, and everything lives in the booking system. Then, somewhere else, sits the rest of your business: a CRM with your contacts, an accounting tool that issues invoices, a Google Sheet where you track revenue, a Slack channel where your team talks.

Without a connection, someone has to copy every booking into those systems by hand. That is slow, error-prone, and it stops being viable the moment your volume grows. Webhooks fix this — they push each booking event to your other tools automatically, the second it happens.

Why connect your booking events to other tools?

No more manual data entry

Every booking appears in your CRM, spreadsheet or accounting tool automatically. Your team stops retyping names, emails and prices — and stops making typos.

Real-time accuracy

The webhook fires the moment the event happens. A cancellation updates your CRM and frees your calendar in other systems instantly — not at the end of the day when someone notices.

Your tools, your way

Webhooks are a universal standard — the same booking data can flow into a CRM, accounting, analytics, helpdesk or a private database. You are not locked into one stack.

Scale without hiring

The more bookings you have, the more manual work webhooks save you. What takes an admin an hour a day becomes an automated pipeline that runs by itself.

What you will be able to automate

Booking event Typical automation Platforms
New booking Create a CRM contact, add a lead, log a Google Sheets row, notify the team Zapier, n8n, Make, Pabbly
Cancellation Update the contact, alert you so you can re-book the slot, mark the record Zapier, n8n, Make, Pabbly
Reschedule Update appointment dates in your CRM and send the customer a confirmation Zapier, n8n, Make, Pabbly
Completion Create the invoice, trigger a review request, record revenue, mark the job done Zapier, n8n, Make, Pabbly

How Clickobook webhooks work

A webhook is an automatic HTTP POST request that Clickobook sends to a URL you control whenever a booking event happens. The request body is a JSON payload describing the booking — and your receiving tool (an automation platform, or your own endpoint) processes it in real time.

POST /your-webhook-url
Content-Type: application/json
X-Booking-Tenant:  t-001
X-Booking-Event:   booking_created
X-Booking-Delivery-Id: 550e8400-e29b-41d4-a716-446655440000

{
  "event": "booking_created",
  "booking_number": "BK-20260901-0042",
  "status": "confirmed",
  "booking_date": "2026-09-05",
  "start_time": "09:00:00",
  "service_name": "Dental Consultation",
  "customer_name": "Paul Johnson",
  "customer_email": "[email protected]",
  "total_price": 200.00,
  "payment_status": "completed",
  "invoice_number": "TEN-MY-BIZ-2026-000123"
}

That is the whole mechanism. Everything else — getting the URL, mapping the fields, running the follow-up action — happens in the tool you connect to. Clickobook simply delivers the event to the URL you configure, and lets you enable or disable each event individually.

💡 What webhooks are not

Webhooks are push, not pull. Your endpoint does not go and fetch data — it is notified with the data. If you also need to pull existing records on demand for a rich two-way integration, you can combine webhooks with the REST API keys available on your plan. For the majority of "send booking to my CRM / spreadsheet / accounting" use cases, webhooks alone are enough.

The four booking events you can subscribe to

Clickobook emits four distinct booking events. Each has its own URL field and its own enable toggle, so you subscribe only to what you need.

1

booking_created

A new booking is made. This is your trigger for creating CRM contacts, logging leads or alerting your team.

2

booking_cancelled

A booking is cancelled. Great for updating your CRM and flagging a freed slot you can re-book.

3

booking_rescheduled

A booking moved to a new date or time. The payload includes the old details in metadata so you can update records.

4

booking_completed

A booking is marked done. The natural trigger for issuing the invoice, recording revenue and sending a review request.

⚠️ Enable each event separately

The per-event toggles matter. If you only tick "Booking created", cancellations and reschedules will not be sent. Decide which events your follow-up actions actually need, and tick those — you can add more later without re-creating your whole integration.

What data each webhook sends

The JSON payload is deliberately flat for the most important fields, so automation platforms can map them directly in their field pickers. Alongside the flat fields there are nested objects for the customer, staff, location, product and plan.

Flat fields you can map in any automation tool

Field Description
idUnique booking ID
booking_numberHuman-readable reference, e.g. BK-20260901-0042
eventThe event type
statusBooking status (pending / confirmed / cancelled, etc.)
booking_dateAppointment date (YYYY-MM-DD)
start_time / end_timeStart / end time
service_nameService or product name
total_priceTotal price (tax included)
currencyCurrency (EUR, USD, RON, etc.)
tax_rate / tax_amount / tax_labelTax percentage, tax amount and tax name
net_pricePrice excluding tax
tax_includedWhether tax is included in total_price
discountTotal discount applied
coupon_codeCoupon code used (if any)
invoice_id / invoice_numberAssociated invoice reference (when available)
payment_method / payment_providerHow the customer paid (card, paypal, at_venue…)
payment_statusPending / completed / failed / refunded
deposit_amountConfigured deposit for the booking
paid_amountActual amount paid so far
balance_dueRemaining balance (0 = fully paid)
customer_name / customer_email / customer_phoneCustomer contact details
staff_nameAssigned staff member
location_name / location_addressWhere the appointment happens
product_nameProduct name (for product services)
plan_namePlan name (for subscription/plan bookings)
tenant_slugYour business's unique slug

In addition to these flat fields, the payload includes nested objects: customer (id, name, email, phone, address), staff, location, product, plan and metadata (e.g. the old date/time on a reschedule). Most automation platforms expose both the flat fields and the nested ones in their mapping UI.

{
  "id": "550e8400-e29b-41d4-a716-446655440000",
  "booking_number": "BK-20260901-0042",
  "event": "booking_created",
  "status": "confirmed",
  "booking_date": "2026-09-05",
  "start_time": "09:00:00",
  "end_time": "10:00:00",
  "service_name": "Dental Consultation",
  "currency": "EUR",
  "total_price": 200.00,
  "tax_rate": 19.0,
  "tax_amount": 31.93,
  "tax_label": "VAT",
  "tax_included": true,
  "net_price": 168.07,
  "discount": 0,
  "coupon_code": null,
  "invoice_id": "31f8c6e4-...",
  "invoice_number": "TEN-MY-BIZ-2026-000123",
  "payment_method": "card",
  "payment_provider": "stripe",
  "payment_status": "completed",
  "deposit_amount": 0,
  "paid_amount": 200.00,
  "balance_due": 0,
  "customer_name": "Paul Johnson",
  "customer_email": "[email protected]",
  "customer_phone": "+40722123456",
  "staff_name": "Dr. Maria Smith",
  "location_name": "Main Clinic",
  "location_address": "123 Main St, Paris, France",
  "product_name": "Dental Consultation",
  "plan_name": null,
  "tenant_slug": "my-business",
  "created_at": "2026-09-01T10:30:00+03:00",
  "customer": {
    "id": "a1b2c3d4-...",
    "name": "Paul Johnson",
    "email": "[email protected]"
  },
  "staff": { "id": "e5f6g7h8-...", "name": "Dr. Maria Smith" },
  "location": {
    "id": "i9j0k1l2-...",
    "name": "Main Clinic",
    "address": "123 Main St, Paris, France"
  },
  "product": { "id": "m3n4o5p6-...", "name": "Dental Consultation" },
  "plan": null,
  "metadata": {}
}

💡 The payload is rebuilt at delivery time

Clickobook sends you the booking's final state — not a snapshot from the moment the event fired. Discounts, the full-payment discount, the payment transaction and the invoice are all included even if they were finalised a moment after the booking was created. For online checkouts, the booking_created event is dispatched a few seconds after payment so your invoice is usually already attached.

Step 1 — Enable webhooks in Clickobook

Everything starts in the admin panel. You add the destination URLs and tick the events you want — no code required.

  1. 1

    Open Settings → Webhooks.

    In the sidebar go to Settings and open the Webhooks tab. (This tab is available on plans that include the webhooks feature.)

  2. 2

    Paste each destination URL.

    There are four fields — Booking Created URL, Booking Cancelled URL, Booking Rescheduled URL and Booking Completed URL. Paste the webhook URL from your automation platform into the field for each event you want to receive.

  3. 3

    Tick the events you want enabled.

    Check the Enabled Events boxes for the events you configured. Remember: if a box is not ticked, that event is not sent.

  4. 4

    (Recommended) Generate a Signing Secret.

    Click Generate Secret to create a signing secret. This lets you cryptographically verify that each webhook really came from Clickobook (see the Security section below). Store it somewhere safe — your automation platform or endpoint uses it to validate requests.

  5. 5

    Save.

    Click Save Webhook Settings. The settings apply immediately — the next matching booking event will be delivered to your URL.

💡 Use the Setup Guide

The Webhooks tab has a Setup Guide button that opens an in-app walkthrough with the event list, payload reference and copy-paste steps for Zapier and n8n — handy reference when you configure a new integration.

Webhooks settings section in Clickobook showing Booking Created/Cancelled/Rescheduled/Completed URL fields, enabled event checkboxes and a signing secret field

⚠️ Test the URL is reachable

When you first set up a webhook, make a test booking to confirm the event arrives. Most automation platforms show the received data in their webhook trigger logs, so you can verify before building the rest of your automation.

Connect with Zapier

No code · 5 minutes

Zapier is the easiest way to connect Clickobook to thousands of apps with no coding. The key trick is that you use Zapier's built-in Webhooks by Zapier trigger to receive each Clickobook event, then chain any Zapier action onto it.

  1. 1

    Create a new Zap with a Webhooks trigger.

    Choose Webhooks by Zapier → Catch Hook as the trigger. Zapier generates a unique URL for you.

  2. 2

    Copy that URL into Clickobook.

    Paste it into the matching Webhook URL field in Settings → Webhooks (e.g. Booking Created URL) and tick the event. Save.

  3. 3

    Trigger a test booking.

    Make a real test booking. Zapier "catches" the payload and lets you confirm the trigger fired.

  4. 4

    Map the fields and add an action.

    In the Zap editor, pick the flat fields like customer_name, customer_email, total_price and booking_date, then add an action — create a contact in HubSpot, a row in Google Sheets, or an invoice in QuickBooks.

  5. 5

    Publish the Zap.

    Turn the Zap on. From now on, every matching booking event runs your automation automatically.

💡 One Zap per event, or use filters

The cleanest setup is one Zap per webhook event you care about (one for created, one for cancelled, etc.) so each automation handles a single clear trigger. You can also use a single Zap and add a Filter step on the event field.

Connect with n8n

Self-hosted · developer friendly

n8n is a powerful, self-hosted workflow automation tool. Because it accepts a standard webhook trigger, Clickobook integrates with it exactly like any other webhook. You get full control over expressions, branches and hundreds of node types — Slack, Google Sheets, QuickBooks, MySQL, SMTP and more.

  1. 1

    Create a workflow with a Webhook trigger.

    Add a Webhook trigger node and set the HTTP method to POST. n8n shows you a Webhook URL (plus a Test URL).

  2. 2

    Paste the Production URL into Clickobook.

    Copy the workflow's Production URL into the matching Clickobook webhook field. The Test URL only works while the workflow is set to "Listen for test event", so use the Production URL for a stable integration.

  3. 3

    Activate the workflow.

    Publish/activate the workflow so it is listening. Then make a test booking in Clickobook to capture a real payload.

  4. 4

    Access the fields with n8n expressions.

    Right after the Webhook trigger you can reference incoming data directly, e.g. the customer name and price. From anywhere in the workflow, refer to the webhook's captured item by name.

  5. 5

    Add your downstream actions.

    Connect the webhook to any nodes you need — log the booking, notify a chat channel, create a CRM record, or write to a database.

// Right after the Webhook trigger node, reference the fields directly:
Customer name:  {{ $json.customer_name }}
Email:          {{ $json.customer_email }}
Booking date:   {{ $json.booking_date }}
Total:          {{ $json.total_price }} {{ $json.currency }}

// From anywhere in the workflow:
{{ $('Webhook').item.json.customer_name }}

💡 Use the delivery headers too

Every request includes X-Booking-Event and X-Booking-Delivery-Id headers. If you build an idempotent integration (one that must not double-process), store the delivery ID and skip any duplicate.

Connect with Make (formerly Integromat)

No code · visual scenario builder

Make lets you build visual automation "scenarios" with drag-and-drop modules. Its Webhooks module receives Clickobook events over a plain HTTP POST, so the booking data arrives as JSON and you map it into your next module — Google Sheets, Slack, Airtable, HubSpot and hundreds more.

  1. 1

    Create a scenario starting with a Webhook module.

    Add the Webhooks module with the Custom webhook option. Make generates a webhook URL and asks you to send a sample payload to "reclaim" it.

  2. 2

    Paste the URL into Clickobook and trigger a test booking.

    Put the Make webhook URL into the matching Clickobook webhook field, then make a test booking. Make captures the JSON as the sample — confirm it and the module's data structure is set.

  3. 3

    Map the fields into your next module.

    You can map the webhook's values — e.g. customer_name, total_price — into a Google Sheets "Add a row" module, a Slack "Post a message" module, or a CRM module.

  4. 4

    Turn the scenario on.

    Save and run the scenario. Make listens continuously and fires it each time Clickobook sends an event.

💡 Split by event inside one scenario

If you use a single Make webhook for several Clickobook events, add a Router module after the webhook and branch on the event field (booking_created / booking_cancelled / booking_rescheduled / booking_completed) so each branch does the right thing.

Connect with Pabbly Connect

No code · affordable alternative

Pabbly Connect is another popular automation platform that accepts webhook triggers directly. Like the others, you create a Webhook trigger, paste its URL into Clickobook, fire a test booking to capture the payload, then build your workflow steps.

  1. 1

    Add a Webhook trigger to your Pabbly workflow.

    Search for the Webhook app and pick the trigger. Capture method POST. Pabbly shows you a webhook URL.

  2. 2

    Paste the URL into Clickobook.

    Put the Pabbly URL into the matching Clickobook webhook field and enable the event. Save.

  3. 3

    Capture the test payload.

    Click "Capture Webhook Response" and make a test booking in Clickobook. Pabbly stores the sample and makes the fields available in the mapper.

  4. 4

    Map fields into your action steps.

    Map customer_email, service_name, total_price etc. into apps like Google Sheets, Gmail, Slack or a CRM action.

💡 It's the same pattern everywhere

Zapier, n8n, Make and Pabbly all work the same way with Clickobook: create a webhook trigger, paste the URL into your settings, fire a test event, then map the JSON. Once you understand one, you can set up any of the others in minutes.

Verifying webhooks with the signing secret

Any public URL can be hit by anything, not just Clickobook. To be sure each webhook is authentic and untampered, set a Signing Secret in Settings → Webhooks. When you do, every request includes an X-Booking-Signature header — an HMAC-SHA256 hash of the raw JSON body, computed with your secret — plus a timestamp and a replay-proof signature that covers it.

Header Description
Content-Typeapplication/json
X-Booking-TenantYour tenant ID (lets you identify which business sent it)
X-Booking-EventThe event type (e.g. booking_created)
X-Booking-Delivery-IdUnique delivery ID — use it to detect duplicates from retries
X-Booking-SignatureHMAC-SHA256 of the payload (legacy — still sent, only when a signing secret is set)
X-Booking-TimestampUnix seconds when the delivery was signed — check it is recent (see below)
X-Booking-Signature-V2t=<unix>,v1=<hmac_sha256("<t>.<body>")> — the timestamp is inside the digest, so an old request cannot be replayed

Example — PHP endpoint

<?php
$payload = file_get_contents('php://input');
$secret  = 'wh_your_signing_secret';

$expected = hash_hmac('sha256', $payload, $secret);
$received = $_SERVER['HTTP_X_BOOKING_SIGNATURE'] ?? '';

if (hash_equals($expected, $received)) {
    // Valid — process the booking
    $data = json_decode($payload, true);
}

Example — Node.js endpoint

const crypto = require('crypto');

const secret = 'wh_your_signing_secret';
const body = JSON.stringify(req.body);
const expected = crypto
  .createHmac('sha256', secret)
  .update(body)
  .digest('hex');

if (expected === req.headers['x-booking-signature']) {
  // Valid — process the booking
}

Recommended — verify the replay-proof signature (V2)

The V2 header is the strongest check: reject anything older than 5 minutes, then recompute the digest over <timestamp>.<body>. Because the timestamp is part of the signed string, an intercepted request cannot be replayed with a fresh t=.

$header = $_SERVER['HTTP_X_BOOKING_SIGNATURE_V2'] ?? '';

if (preg_match('/^t=(\d+),v1=([a-f0-9]{64})$/', $header, $m)) {
    $timestamp = (int) $m[1];

    if (abs(time() - $timestamp) > 300) {
        http_response_code(400); // too old — possible replay
        exit;
    }

    $expected = hash_hmac('sha256', $timestamp.'.'.$payload, $secret);

    if (! hash_equals($expected, $m[2])) {
        http_response_code(401); // bad signature
        exit;
    }
}

// Authentic and fresh — process the booking

Keep verifying X-Booking-Signature if you already do — it is still sent, unchanged.

Example — PHP endpoint

<?php
$payload = file_get_contents('php://input');
$secret  = 'wh_your_signing_secret';

$expected = hash_hmac('sha256', $payload, $secret);
$received = $_SERVER['HTTP_X_BOOKING_SIGNATURE'] ?? '';

if (hash_equals($expected, $received)) {
    // Valid — process the booking
    $data = json_decode($payload, true);
}

Example — Node.js endpoint

const crypto = require('crypto');

const secret = 'wh_your_signing_secret';
const body = JSON.stringify(req.body);
const expected = crypto
  .createHmac('sha256', secret)
  .update(body)
  .digest('hex');

if (expected === req.headers['x-booking-signature']) {
  // Valid — process the booking
}

💡 Use always-on HTTPS

Always expose your webhook endpoint over HTTPS, and use the signing secret for production. The delivery ID header is your idempotency key — if you see the same X-Booking-Delivery-Id more than once (a retry), skip the duplicate instead of double-processing.

Retries, backoff and delivery reliability

Webhooks are delivered by a background queue, which gives you automatic retries if your endpoint is temporarily unreachable.

Up to 3 attempts with exponential backoff

Each event is attempted up to 3 times. If the first send fails (e.g. your endpoint returns an error or times out), Clickobook waits and retries — roughly 1 minute, then 5 minutes, then 30 minutes — before marking the delivery as failed.

Delivery history is logged

Every delivery is recorded with its event, target URL, attempt count, HTTP response status and error, timestamps and whether it was delivered, failed or skipped. This makes troubleshooting a broken endpoint straightforward.

⚠️ Webhooks work even if your site is slow

Delivery runs on Clickobook's background workers with a short HTTP timeout. Your endpoint does not need to be fast — it just needs to accept the POST. If it returns a non-success status, the retry schedule above kicks in automatically.

Real-world automation ideas (recipes)

These are the most common Clickobook webhook automations we see. Each works with any of the four automation platforms above.

New booking → new CRM contact

On booking_created, create a contact in HubSpot / Salesforce / Pipedrive using customer_name, customer_email and customer_phone — optionally create an opportunity from service_name + total_price.

Every booking → Google Sheets row

Keep a live revenue and booking log. Append booking_number, date, service, customer and total_price as a new row on each event — perfect for simple dashboards and reports.

New / cancelled booking → team notification

Post to Slack or Microsoft Teams when a booking is created (so staff see it) and when one is cancelled (so you can re-book the slot fast).

Completed booking → invoice & review request

On booking_completed, create an invoice in QuickBooks/Xero using the tax and totals (net_price, tax_amount, total_price), and send a review request to boost your social proof.

Catch unpaid balances

Watch the balance_due field. When a booking has a balance due (deposit paid, full amount not yet collected), trigger a reminder automation or flag the row in your tracking sheet.

✅ Your webhook setup checklist

  • 1. Decide which events you need (created / cancelled / rescheduled / completed).
  • 2. Create a webhook trigger in Zapier, n8n, Make or Pabbly and copy its URL.
  • 3. Paste the URL into the matching field in Settings → Webhooks and tick the event.
  • 4. Generate a Signing Secret and set it in your endpoint / platform for verification.
  • 5. Save, then make a test booking to confirm the event arrives.
  • 6. Map the fields and add your action, then publish/enable the automation.
  • 7. Watch the delivery log if something does not arrive — it shows attempts, status codes and errors.
FAQ

Booking webhook integrations — frequently asked questions

Put your booking data to work automatically

Clickobook pushes every booking event to your CRM, accounting, spreadsheets and chat — with retries, signature verification and 0% commission. Start your free trial and connect your first webhook in minutes.