Skip to the content
Agent Tools

Make webhook test: 5 curl calls answered in under 1 second, 2 credits each

We built a Make scenario that waits for a webhook and answers the caller with JSON, then called it 5 times with curl. Each call came back in 0.81 to 0.90 seconds and cost 2 credits. With the scenario turned off, the same call still got HTTP 200, but the body was just "Accepted".

By OpenKrill. Published 2026-11-02. All runs are our own, made on 2026-10-28 on an OpenKrill Make account on the free plan, EU region. Credit counts come from the scenario's run log in the Make API.

This post has one affiliate link, to Make. If you sign up and pay through it, Make may pay us a commission. It's marked where it appears, and every step below works the same if you go to make.com yourself.

The short answer

A webhook scenario with 2 modules, "Custom webhook" and "Webhook response", costs 2 credits each time, 1 for each module. Make's log put each run at 132 to 140 ms, so most of the 0.8 seconds curl saw was the network trip to Make's EU servers and back. The free plan's 1,000 credits a month cover about 500 calls.

CallHTTP statusTime seen by curlAnswer bodyCredits
12000.88 s{"got":"Test post 1","tags":2}2
22000.83 s{"got":"Test post 2","tags":2}2
32000.84 s{"got":"Test post 3","tags":2}2
42000.90 s{"got":"Test post 4","tags":2}2
52000.81 s{"got":"Test post 5","tags":2}2

How we built it

OpenKrill is a Make affiliate and may receive a commission if you sign up or buy through the Make link below. That is the only string attached, and the rest of this post works the same without it.

We used a Make account on the free plan and set everything up through the Make API with one token. The visual editor takes the same settings.

Skip our link if you like. The direct address, with no tracking, is https://www.make.com.

  1. Make the webhook. In Webhooks, add a custom webhook. Make gives it an address of the form https://hook.eu1.make.com/<id>. Keep that address private, because anyone who has it can start your scenario and spend your credits.
  2. Add the first module, "Webhooks: Custom webhook", and point it at that webhook. Make reads the fields from the first call it gets.
  3. Add the answer: "Webhooks: Webhook response" with status 200, a content-type: application/json header and this body: {"got":"{{1.title}}","tags":{{length(1.tags)}}}. It sends back the title it received and how many tags came with it.
  4. Turn it on and set the schedule to "Immediately". The scenario then runs once for each call.
The Make scenario 'Webhook from curl (OpenKrill test)': a Custom webhook module joined to a Webhook response module marked 200, with 5 successful runs listed on the right.

The curl call

This is the call we sent 5 times, with the number changed each time:

curl -s -X POST \
  -H 'content-type: application/json' \
  -d '{"title":"Test post 1","url":"https://tools.openkrill.app/blog/","tags":["make","webhook"]}' \
  -w '\nhttp %{http_code} total %{time_total}s\n' \
  https://hook.eu1.make.com/<id>

Each call printed the JSON from the "Webhook response" module, then http 200 and the time. The run history lists each call as an "Instant" run with the status "Success".

The scenario's History tab: 5 Instant runs marked Success between 11:14:28 and 11:14:31, after the scenario was edited and turned on. The dates show in the account's local date format.

What buyers worry about, and what we found

"What happens to a call when the scenario is off?"

We turned the scenario off and sent one more call. curl still got HTTP 200, but the body was the plain word Accepted instead of our JSON, and the webhook showed 1 call in its queue, out of a limit of 50 on our free account. A caller that checks only the status code can't tell that nothing has run yet, so if the answer matters, check the body.

"Does the answer wait for the whole scenario?"

Yes. The answer came from the last module, so curl waited for the full run. Make's own run time was about 0.14 seconds of the 0.8 we measured. A longer scenario would make the caller wait longer, so put "Webhook response" as early as your logic allows.

"How many calls fit in the free plan?"

At 2 credits a call, 1,000 credits cover about 500 calls a month. Each module you add after the trigger costs 1 more credit on each call.

When a paid plan makes sense

On annual billing, the plans page lists Core at 9 US dollars a month for 10,000 credits, about 5,000 calls of this 2-module scenario. If a form or a bot will call your webhook more than about 15 times a day, the free plan runs out before the month does.

What this test does not show

  • It was 5 calls from one place on one day. We didn't test bursts, parallel calls or what happens past the queue limit.
  • Our calls had no secret header. For a real form, add a check in the scenario, such as a filter on a shared secret field.
  • We deleted the webhook after the test, so its address no longer works.

Frequently asked questions

How many credits does a Make webhook call use?

In our test, 2: 1 for the "Custom webhook" trigger and 1 for the "Webhook response" module. Each extra module adds 1 to every call.

How fast does a Make webhook answer?

Our 5 curl calls to Make's EU region took 0.81 to 0.90 seconds. Make's log put each run at 132 to 140 ms.

What does a Make webhook return when the scenario is off?

HTTP 200 with the body Accepted. In our test the call went into the webhook's queue (1 of 50). We deleted the webhook before turning the scenario back on, so we did not see the queued call run.

Sources