Make.com Webhooks: Beginner's Setup Guide

Quick answer: what a Make.com webhook does

A Make.com custom webhook gives another app an HTTPS URL that can start a scenario as soon as data arrives. The basic setup is: add Webhooks > Custom webhook, copy the generated URL, select Run once, send one representative sample, map the captured fields into later modules, test the complete path and then activate the scenario.

For conditional logic after the webhook, consult the Make.com if() function guide.

That is usually better than repeatedly asking an app whether anything has changed. A webhook is event-driven; a polling trigger checks on a schedule. Make's official webhook documentation confirms that custom webhooks receive data over HTTPS, normally trigger immediately and place incoming requests in a queue.

Five-minute setup checklist

1. Create a new scenario and add Webhooks > Custom webhook as the first module.
2. Give the hook a useful name and copy its URL. Treat that URL like a secret because anyone who has it may be able to trigger the scenario.
3. Select Run once, then send a realistic test payload from your form, app or API client.
4. Inspect the captured bundle and map only the fields required by the next module.
5. Add error handling, test both valid and invalid input, activate the scenario and monitor its queue and execution history.

Instant webhook vs scheduled polling

Question	Instant webhook	Scheduled polling
How it starts	The source pushes data to Make	Make asks the source for new data
Typical timing	Immediately after receipt	At the configured interval
Best fit	Forms, orders, alerts and callbacks	Services without webhook support or periodic batch work
Main operational risk	Bursts, duplicate requests and out-of-order parallel runs	Delay, repeated API calls and missed items if the query is weak

Use a webhook when the source can send a trustworthy event. Use polling when it cannot, or when batching is intentional.

Download the Google Docs webhook script

Download the Google Docs Apps Script example (plain text, 2 KB). It checks the HTTP response before showing an acceptance message. Setup instructions and the complete code are below.

The Video Guide

Video not loading? Watch on YouTube

Reliability, queues and webhook responses

By default, instant webhook executions can run in parallel. If order matters, enable Process data in order in the scenario settings. Make then waits for one execution to finish before starting the next. For bursts, inspect the webhook queue and set a sensible scenario rate limit so a downstream API is not overwhelmed.

The Webhook response module controls what the caller receives. Put it at the end when you want an upstream failure to remain visible; responding too early can tell the caller everything succeeded even if a later module fails. Design callers to retry HTTP 429 and temporary 5xx responses, and use an idempotency key or source event ID where duplicate processing would be costly.

Make.com webhook not working: what to check

What you see	Next check
No captured bundle	Confirm the sender used the correct hook, then inspect its request and Make's webhook log. Use Run once while capturing a sample.
HTTP 200 Accepted, but no finished task	Inspect the queue, schedule and execution history. Make's default acceptance response confirms receipt, not completion of every later module.
HTTP 400	Read the response and check the input. Make can also return 400 when the webhook queue is full.
HTTP 429	Reduce the request rate and retry with a delay. Use an event ID to avoid processing the same event twice.
HTTP 410	Check whether the hook is still attached to a scenario. Make documents deactivation of unattached hooks after five days.

These status examples follow Make's webhook documentation. A custom Webhook response module can change what the sender receives.

For a captured status such as paid or pending, use the tested switch() example to choose a label. Use a router when the status needs to trigger different modules.

Security checks before activation

• Never paste the webhook URL into a public page, screenshot or client-side repository.
• Validate a shared secret or signed request when the sending service supports it.
• Reject unexpected methods, content types and oversized payloads.
• Map only required fields and avoid storing credentials or unnecessary personal data in execution logs.
• Test missing fields and malformed arrays, not only the happy path.

For transforming captured arrays, see my Make.com map function guide.

Creating a Form with a Webhook in Make.com 📝🔗

Using webhooks with forms allows you to instantly capture and process form submissions in Make.com. Whether you’re collecting leads, handling support requests, or automating order processing, a webhook ensures that form data is sent and processed in real-time.

🚀 Why Use a Webhook with a Form?

• Instant Data Transfer: No need to manually check form submissions-webhooks push data automatically.
• Automation: Trigger actions like email notifications, CRM updates, or database entries upon form submission.
• Integration: Connect form submissions to multiple apps using Make.com’s automation scenarios.

📌 Step-by-Step Guide to Setting Up a Webhook for a Form

🔹 Step 1: Create a Webhook in Make.com

1. Log into your Make.com account.
2. Create a new scenario and select the Webhooks module.
3. Choose Custom Webhook and click Add.
4. Make.com will generate a Webhook URL. Copy this URL-you’ll need it for your form.

🔹 Step 2: Connect the Webhook to Your Form

Depending on the form provider you use, you need to configure it to send data to the webhook.

• Typeform: Navigate to Connect → Webhooks, then paste the webhook URL.
• WordPress Forms (WPForms, Gravity Forms, etc.): Use their webhook add-ons to send form submissions to Make.com.
• Custom website form: submit to an endpoint on your own server. Validate the submission and apply abuse controls there, then forward the required fields to Make from the server. Keep the Make URL in server configuration; putting it in a public form's action attribute exposes it to visitors.

🔹 Step 3: Test the Webhook Connection

1. Go back to Make.com and click Run Once on your scenario.
2. Submit a test entry through your form.
3. Make.com should receive the data instantly.
4. Check the received data and configure further actions (e.g., send an email, save to Google Sheets, or update a CRM).

🔹 Step 4: Automate Actions Based on Form Data

Once the webhook is working, you can automate multiple processes:

• Send a Confirmation Email: Use the Email module in Make.com.
• Store Data in a Google Sheet: Add a Google Sheets module to save form responses.
• Update CRM (HubSpot, Salesforce, etc.): Use a CRM integration to create a new contact.
• Send a WhatsApp or Slack Notification: Trigger a message to inform your team about new submissions.

Secret JT Tip 🚨

When creating an email response after a form submission, do you want this to feel ‘real’?

Option 1 – A ‘pretty’ HTML email sent from your CRM. Then just chuck the submission in your CRM.

Option 2 (the secret tip) – A ‘real’ email sent from one of your team. Add a delay timer to your scenario, spice it up with some AI and then send an email as if a person has followed up almost instantly with your enquiry. From a user perspective this appears as if you are ‘on it’ when really you might be on the beach! 🏖️

Handling arrays (repeater fields)

When working with webhooks, APIs, or form submissions in Make.com, you might receive data in an array format. This often happens with repeater fields in forms, multi-item selections, or API responses containing multiple records. To process each item individually, Make.com provides the Iterator module.

🚀 Why Use an Iterator?

• Breaks down an array into individual items for further processing.
• Automates looping through multiple records in one scenario execution.
• Prepares data for structured storage, messaging, or API integration.

📌 Example: Processing a Repeater Field from a Form

Imagine a form where users can add multiple attendees to an event registration. The form might send the following JSON data to Make.com via a webhook:

{
  "event_name": "Tech Conference 2025",
  "attendees": [
    {
      "name": "Alice",
      "email": "[email protected]"
    },
    {
      "name": "Bob",
      "email": "[email protected]"
    },
    {
      "name": "Charlie",
      "email": "[email protected]"
    }
  ]
}

🔹 Step 1: Capture the Webhook Data

1. In Make.com, create a new scenario and select the Webhooks module.
2. Choose Custom Webhook and generate a Webhook URL.
3. Send a test form submission to capture the webhook data.

🔹 Step 2: Add an Iterator Module

1. After the Webhook module, add an Iterator module.
2. For the Array Source, select attendees[] from the webhook response.
3. Now, the Iterator will loop through each attendee separately.

🔹 Step 3: Process Each Item

Now that each attendee is processed separately, you can:

• Send an email confirmation to each attendee using the Email module.
• Store each attendee in a Google Sheets or database.
• Send a WhatsApp or Slack notification for each registrant.

🔹 Step 4: Test the Workflow

1. Click Run Once to test the scenario.
2. Submit the form again with multiple attendees.
3. Check that each attendee is processed separately.

Post a Google Docs document ID to Make with Apps Script

This bound Apps Script adds a Custom Actions > Submit Document menu to a Google Doc. It sends that document's ID, not its contents, to your Make webhook. It does not change sharing permissions; a later Make module still needs authorised access if it is to read the document.

Set up the example

1. Open a test Google Doc and select Extensions > Apps Script. Paste the code below and save it.
2. In the Apps Script project's settings, add a script property named MAKE_WEBHOOK_URL containing your own HTTPS Make webhook URL. People who can edit the script can read this property; use a document and script shared only with appropriate collaborators.
3. Reload the Doc so its custom menu appears. In Make, select Run once, then use Custom Actions > Submit Document and review the Google permissions requested by your script.
4. Inspect Make's captured documentId and execution history. Use a test document and verify the whole workflow before using real content.

Download this Apps Script as a plain-text file.

Why the response code matters

With muteHttpExceptions: true, an HTTP error can return a response object without throwing an exception. The script checks getResponseCode() before showing an acceptance message; it does not report success unconditionally.

An HTTP 2xx response means the request was accepted at the HTTP level. Check Make's execution history to confirm subsequent work completed. Redirects are not followed automatically, and an error alert omits the private webhook URL.

Test scope, 30 October 2026: response handling passed ten simulated tests: 200, 202, 204, 400, 401, 429, 500, a transport error, a missing URL and a non-HTTPS URL. These were unit tests with simulated Apps Script services, not a live Google Docs-to-Make integration test. Run the setup check above for your own account.

/**
 * Bound Google Docs Apps Script example, checked 30 October 2026.
 * In Project Settings > Script properties, set MAKE_WEBHOOK_URL to your
 * own Make custom webhook URL. People who can edit the script can read it.
 * Sends only the current document ID. It does not change document sharing.
 */
function onOpen() {
  DocumentApp.getUi().createMenu('Custom Actions')
    .addItem('Submit Document', 'postDocumentIDToWebhook').addToUi();
}

function postDocumentIDToWebhook() {
  const ui = DocumentApp.getUi();
  const webhookUrl = PropertiesService.getScriptProperties()
    .getProperty('MAKE_WEBHOOK_URL');

  if (!webhookUrl || !webhookUrl.startsWith('https://')) {
    ui.alert('Set MAKE_WEBHOOK_URL to your HTTPS Make webhook URL in Script properties first.');
    return;
  }

  try {
    const documentId = DocumentApp.getActiveDocument().getId();
    const response = UrlFetchApp.fetch(webhookUrl, {
      method: 'post',
      contentType: 'application/json',
      payload: JSON.stringify({ documentId: documentId }),
      muteHttpExceptions: true,
      followRedirects: false,
    });
    const status = response.getResponseCode();

    if (status >= 200 && status < 300) {
      ui.alert('The webhook accepted the request (HTTP ' + status + '). Check Make execution history to confirm the later steps completed.');
    } else {
      ui.alert('The webhook returned HTTP ' + status + '. Check the URL, request format and Make execution history before trying again.');
    }
  } catch (error) {
    ui.alert('The request could not be completed. Check your Apps Script permissions and execution log before trying again.');
  }
}

✅ Beginner’s Checklist for Webhooks in Make.com

Before you wrap up, use this quick checklist to ensure you’re set up correctly with webhooks in Make.com:

• 🔗 Webhook URL Generated: Created a custom webhook in Make.com and copied the URL.
• 📩 Data Source Connected: Configured an external app (e.g., Google Forms, Typeform, CRM) to send data to the webhook.
• 🔄 Webhook Trigger Set Up: Defined an event (e.g., form submission, payment received) to activate the webhook.
• 🛠 Scenario Created in Make.com: Built an automation workflow that processes incoming webhook data.
• 📊 Data Mapped Correctly: Checked and assigned the right data fields in Make.com.
• ⚙️ Automation Actions Configured: Connected the webhook to other apps (e.g., Google Sheets, Email, Slack, CRM).
• 🧪 Tested the Webhook: Sent test data and verified if Make.com processed it correctly.
• 🚀 Scenario Activated: Turned on automation for real-time execution.