# Make webhooks in production: duplicates, ordering, retries and timeouts

Agent skill: `npx skills add hookdeck/webhook-skills --skill make-webhooks` ([details](https://hookdeck.com/webhooks/make/skill))

This guide covers the problems you meet when a Make scenario calls your endpoint with the HTTP app's **Make a request** module, and how to handle each one. It doesn't cover Make's own Webhooks app, which [sends data into Make](https://help.make.com/webhooks) to trigger a scenario. For that direction, see [how to solve Make webhook rate limit errors](/webhooks/platforms/how-to-solve-make-com-webhook-rate-limit-errors).

What Make sends is on the [Make webhooks](/webhooks/make) overview, and how to check the key is on [Verify Make webhooks](/webhooks/make/verify).

## At a glance

| Problem | What to do | With Event Gateway |
| --- | --- | --- |
| [Timeouts](#timeouts) | Respond inside the module's timeout; process in a background job | Answers the module at once, then queues the request for your service |
| [Duplicates](#duplicates) | Put a stable `id` in the body and skip ids you've processed | Drops repeats before they reach your handler |
| [Ordering](#ordering) | Expect overlap; use **Process data in order** or fetch current state | Logs every request, so you can see arrival order when debugging |
| [Retries](#retries) | Set **Return error if HTTP request fails**, store incomplete executions and test the result | Accepts requests while your service is down and retries on your schedule |
| [Choosing events](#choosing-events) | Name the event in every body | Filters and routes on the fields you send |
| [Testing](#testing) | Use a public HTTPS URL that forwards to localhost | Forwards to localhost and replays past requests |
| [Other limits](#other-limits) | Use a keychain in the header, and list your origin on it | Compares the key header, and shows failures Make can't see |

## Make module timeouts and slow handlers {#timeouts}

Respond inside the module's **Timeout**, then do the work in a background job. You set the timeout on each module, from 1 to 300 seconds. Make doesn't document the default.

**Why it happens:** The module waits for your response, so a slow handler holds up the scenario. If your endpoint takes longer than the timeout, the module can fail with a `ModuleTimeoutError`, and Make can [rerun it](#retries) even though your handler is still working.

**Fix it in your handler:**

1. Check the key, store the request and return `200`. See [why to process webhooks asynchronously](/webhooks/guides/why-implement-asynchronous-processing-webhooks).
2. Do the work in a worker, outside the request.
3. Set a **Timeout** that fits how quickly your endpoint really responds.

**With Event Gateway:** Hookdeck answers the module as soon as a request arrives, then queues it and delivers it to your service at a rate it can handle. Your handler can take as long as it needs without holding up the scenario.

## Duplicate Make requests {#duplicates}

Your endpoint can receive the same request more than once. Put a stable `id` in the body, taken from the record the scenario is handling, and skip ids you've processed.

**Why it happens:** Make [reruns failed runs](https://help.make.com/automatic-retry-of-incomplete-executions) starting with the module that caused the error, so a timed-out request goes out again even if your endpoint finished the work. [Scenario run replay](https://help.make.com/scenario-run-replay) sends it again too. Make adds no delivery id, so your endpoint has nothing to compare unless the body carries one.

**Fix it in your handler:**

1. Map an identifier from an earlier module into `id` in the body.
2. Track processed ids in a table with a unique constraint.
3. Make every handler [idempotent](/webhooks/guides/implement-webhook-idempotency).

**With Event Gateway:** Hookdeck [deduplicates](/docs/deduplication) requests before they reach your endpoint, using the fields you choose.

## Out-of-order Make requests {#ordering}

Don't assume requests arrive in the order things happened. Turn on **Process data in order** if the sequence matters, or fetch the record's current state from its source.

**Why it happens:** [Instant scenarios run in parallel by default](https://help.make.com/webhooks), so Make doesn't wait for one run to finish before starting the next. Retries add to this: a rerun can arrive hours after requests from newer runs.

**Fix it in your handler:**

1. Include a timestamp from the source record in the body, and ignore anything older than what you've stored.
2. Or fetch current state from the source system when the request arrives.
3. If you turn on **Process data in order**, expect the scenario to pause while it has incomplete executions, which delays later requests.

**With Event Gateway:** Hookdeck logs every request and attempt, so you can see arrival order when debugging. For more on the general problem, see [Webhook Ordering: Why It's Hard and How to Handle It](/webhooks/guides/webhook-ordering-why-its-hard-and-how-to-handle-it).

## Make retries and disabled scenarios {#retries}

The module has no retry setting of its own, but Make reruns scenarios after some errors, and it can disable a scenario that keeps failing. Decide what you want to happen, then test it against a `500`.

**Why it happens:** Make [retries automatically](https://help.make.com/automatic-retry-of-incomplete-executions) after a `ConnectionError`, a `RateLimitError` or a `ModuleTimeoutError`. Make [identifies a `ConnectionError` by a `503` or `504`](https://help.make.com/fix-connection-errors) and a [`RateLimitError` by a `429`](https://help.make.com/fix-rate-limit-errors). With [incomplete executions](https://help.make.com/incomplete-executions) stored, which is off by default, there are up to 8 attempts over about 8 hours, and then the run waits for you to resolve it. With them off, [an instant scenario is rerun with backoff, while a scheduled one isn't](https://help.make.com/fix-connection-errors): Make pauses its schedule for 20 minutes instead.

Other errors aren't retried by default. [A scenario is disabled](https://help.make.com/Overview-of-error-handling) after 3 errors in a row by default, or at its first error if it starts with an instant trigger.

The module's page doesn't say which of these errors a given response produces, and the stop itself depends on one setting: the scenario stops on a `4xx` or `5xx` only if **Return error if HTTP request fails** is set to **Yes**.

**Fix it in your scenario and handler:**

1. Set **Return error if HTTP request fails** to **Yes**, so failures appear in the scenario's history.
2. Turn on **Store incomplete executions** in the scenario settings, so failed runs are kept.
3. Add an [error handler](https://help.make.com/Overview-of-error-handling) to the module where you want a set behaviour. The [Retry handler](https://help.make.com/retry-error-handler) defaults to 3 attempts, 15 minutes apart.
4. Return `503` or `429` from your endpoint for temporary problems and another `4xx` for bad requests, then test what your scenario does with each.

**With Event Gateway:** Hookdeck accepts each request as soon as it arrives and stores it, then delivers it to your service with [retries](/docs/retries) on a schedule you control. An outage on your side doesn't become an error in the scenario.

## Choosing events: Make has no event list {#choosing-events}

Make has no event catalogue for these requests, because every request is built in a scenario. Your events are whatever your scenarios report, so name them yourself.

**Why it happens:** Make doesn't define what arrives at your endpoint. The person building the scenario chooses the method, headers, query parameters and body, usually by mapping values from earlier modules. Make adds no event name and no envelope.

**Fix it in your scenario:**

1. Agree on a body format with whoever builds the scenarios, and keep it the same across them:
  
  
  ```json
  {
    "event": "lead.created",
    "occurred_at": "2026-10-22T09:15:00Z",
    "id": "{{1.id}}",
    "data": {
      "email": "{{1.email}}",
      "company": "{{1.company}}"
    }
  }
  
  ```
  
  
  
  The `{{1.id}}` placeholders stand for values mapped from earlier modules, and the event name here is only an example.
2. Use **application/JSON** with a **Data structure**. Make then escapes reserved characters in mapped values for you. With **JSON string**, you have to escape them yourself, and a mapped value containing a quote breaks the body.
3. Validate the body on arrival and return `400` for anything that doesn't match, so the error shows up in Make.
4. Use one method per endpoint. Choose `POST` unless you have a reason not to.

**With Event Gateway:** Hookdeck stores every request with its full body, so you can see what each scenario sends. [Filters](/docs/filters) route on the fields you send, and [transformations](/docs/transformations) can normalise different shapes into one.

## Testing Make requests locally {#testing}

Point the module at a public HTTPS URL that forwards to your machine, then use **Run once** in the Scenario Builder.

**Why it happens:** Make's cloud can't reach `localhost`. It allows only HTTPS, and it rejects self-signed certificates.

**How to test it:**

1. Run `hookdeck listen 3000 make` and use the URL it prints as the module's **URL**.
2. Run the scenario once, then check the module's output bundle for your response status and body.
3. To send the same data again, use [scenario run replay](https://help.make.com/scenario-run-replay), which runs the current scenario with a past run's trigger data.

**With Event Gateway:** The [Hookdeck CLI](/docs/cli) forwards requests to localhost, and you can replay past requests without running the scenario again.

## Other Make limits {#other-limits}

**A static key isn't a signature.** The module's authentication types are **API key**, **Basic Auth** and **OAuth 2.0**, and none of them signs the body. An API key sends the same value on every request, so anyone who learns it can send requests that look like yours. Use a long random key in the header, a separate keychain per environment, and deduplicate on `id` so a replayed request has no further effect.

**Put the key in a keychain.** Make recommends the **Credentials** field over **Headers** or query parameters, because it avoids exposing keys in requests and makes rotation safe. Editing a keychain under **Keys** updates every module that uses it.

**A keychain can restrict its origins.** With [Restrict requests to service URLs](https://apps.make.com/api-key-authentication-type) on, Make sends the key only to the HTTPS origins in **Allowed service origins**. Add your endpoint's origin to the keychain.

**Make publishes its outgoing IPs.** If your endpoint sits behind a firewall, [allow the addresses for your Make zone](https://help.make.com/allow-connections-to-and-from-make-ip-addresses).

**With Event Gateway:** Create a source with the Make type, then enter the API key parameter name as **API Key Header** and the exact Key as **API Key**, including any prefix. The source type pre-selects `POST`. If your module uses `GET`, `PUT`, `PATCH` or `DELETE`, allow that method on the source too. Don't use `OPTIONS`, because Hookdeck answers it as a CORS preflight and never turns it into an event. A keychain placed in the query parameters, Basic Auth and OAuth 2.0 can't be checked by this source type.

Hookdeck answers the module itself, before your service sees the request, so **Return error if HTTP request fails** never triggers for problems further along, or for a wrong key. Watch Hookdeck rather than the scenario's history: [issues](/docs/issues) alert you when deliveries to your service fail, and every request is listed with its headers and body, including those that failed verification.

[Get started with Hookdeck](https://dashboard.hookdeck.com/signup) for free and receive Make scenario requests reliably in minutes.