Make webhooks in production: duplicates, ordering, retries and timeouts
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 to trigger a scenario. For that direction, see how to solve Make webhook rate limit errors.
What Make sends is on the Make webhooks overview, and how to check the key is on Verify Make webhooks.
At a glance
| Problem | What to do | With Event Gateway |
|---|---|---|
| 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 | Put a stable id in the body and skip ids you've processed | Drops repeats before they reach your handler |
| Ordering | Expect overlap; use Process data in order or fetch current state | Logs every request, so you can see arrival order when debugging |
| 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 | Name the event in every body | Filters and routes on the fields you send |
| Testing | Use a public HTTPS URL that forwards to localhost | Forwards to localhost and replays past requests |
| 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
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 even though your handler is still working.
Fix it in your handler:
- Check the key, store the request and return
200. See why to process webhooks asynchronously. - Do the work in a worker, outside the request.
- 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
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 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 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:
- Map an identifier from an earlier module into
idin the body. - Track processed ids in a table with a unique constraint.
- Make every handler idempotent.
With Event Gateway: Hookdeck deduplicates requests before they reach your endpoint, using the fields you choose.
Out-of-order Make requests
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, 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:
- Include a timestamp from the source record in the body, and ignore anything older than what you've stored.
- Or fetch current state from the source system when the request arrives.
- 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.
Make retries and disabled scenarios
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 after a ConnectionError, a RateLimitError or a ModuleTimeoutError. Make identifies a ConnectionError by a 503 or 504 and a RateLimitError by a 429. With 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: Make pauses its schedule for 20 minutes instead.
Other errors aren't retried by default. A scenario is disabled 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:
- Set Return error if HTTP request fails to Yes, so failures appear in the scenario's history.
- Turn on Store incomplete executions in the scenario settings, so failed runs are kept.
- Add an error handler to the module where you want a set behaviour. The Retry handler defaults to 3 attempts, 15 minutes apart.
- Return
503or429from your endpoint for temporary problems and another4xxfor 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 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
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:
Agree on a body format with whoever builds the scenarios, and keep it the same across them:
{ "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.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.
Validate the body on arrival and return
400for anything that doesn't match, so the error shows up in Make.Use one method per endpoint. Choose
POSTunless 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 route on the fields you send, and transformations can normalise different shapes into one.
Testing Make requests locally
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:
- Run
hookdeck listen 3000 makeand use the URL it prints as the module's URL. - Run the scenario once, then check the module's output bundle for your response status and body.
- To send the same data again, use scenario run replay, which runs the current scenario with a past run's trigger data.
With Event Gateway: The Hookdeck CLI forwards requests to localhost, and you can replay past requests without running the scenario again.
Other Make 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 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.
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 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 for free and receive Make scenario requests reliably in minutes.
Keep an outage on your side from disabling a Make scenario.
Event Gateway accepts each request from the module as it arrives, queues it and retries to your service on your schedule, so your downtime doesn't become an error in the scenario.