Make is for the call routing that needs an if statement
A scenario starts from our webhook, then branches, loops and reshapes the call data before anything downstream sees it. We have no app in Make's directory yet, so the webhook is the way in.
Caller
“The tenant in unit four has no hot water. I'm the property manager. Who do I speak to on a weekend?”
What happened next
- Call captured with the caller's name, number and the property they mentioned
- Make's webhook module caught the event and matched the reason for calling to your emergency branch
- Router sent it to the on-call tech and skipped the normal work queue
How GreetKeeper connects to Make
Three states, and we publish the one that is true rather than the one that reads best.
| Tool | How it connects | What that means |
|---|---|---|
| Make | Through Zapier |
What Make is
Make is a visual automation tool. You build a scenario on a canvas by dragging modules and joining them with lines. Each module is one app doing one thing.
The difference people care about is shape. A Make scenario can split into several paths with a router, run a filter on each path, and loop over a list. You can see the whole flow at once instead of reading a list of steps.
Make also lets you inspect the raw data between modules. If a field arrives in the wrong format, you fix it with a function in the next module rather than giving up on the flow.
How the call moves through a scenario
GreetKeeper's webhook lands in the first module. Everything after that is yours to shape.
Your scenario reads the event type, the caller's name and number, the reason for calling, the outcome and the transcript link. You then branch. A reason that mentions a leak goes one way, a price question goes another, and everything else falls through to a default path.
The payload links to the transcript instead of carrying the text. Most scenarios pass that link along, so the person who picks up the job can open the full call. You can also call an external service mid-scenario and feed its answer into the next step.
Make keeps an execution history with the data at every module. When a run goes wrong, you click the failed module and read exactly what it received. That detail is the main reason people move here from a simpler connector.
Building the scenario
Start narrow: one webhook, one destination, no router until that works.
Create a scenario that starts with Make's custom webhook
Add Make's Webhooks module, choose the custom webhook, and copy the address Make generates. Paste that address into GreetKeeper as your webhook URL. A scenario that starts this way runs when the event arrives, so there is no polling schedule to set.
Run it once to capture a real call
Place a test call while Make is listening for data. Make learns the payload's structure from that first request, and every later module can map fields from it by clicking rather than typing.
Add a router and write your filters
Give each path a filter with a plain condition, such as the reason for calling containing a word you care about, or the event type being booking.created. Name the paths. An unnamed router becomes unreadable within a month.
Set error handling on the modules that can fail
Right-click a module and add an error handler. Send yourself a note on failure instead of letting the run stop quietly. Then switch the scenario on and place a second test call.
Where a Make scenario stops
Questions about Make and GreetKeeper
Is there a GreetKeeper app inside Make?
Not yet. Search Make's app list and you won't find us. Use Make's own custom webhook as the first module, and point GreetKeeper's webhook at the address it gives you.
Should I use Make or Zapier?
Both catch the same GreetKeeper webhook. Make suits branching, loops and data reshaping. Zapier suits one hook and one action with the least setup, and its webhook trigger needs a paid Zapier plan. Plenty of people run both for different jobs.
Does the paid Zapier plan rule apply here?
No, because Zapier isn't involved. That rule covers Webhooks by Zapier only. Make has its own plans and operation limits, so check those against the number of calls you expect.
Can Make read the full transcript?
The webhook carries a link to the transcript, not the text itself. Your scenario can branch on the reason for calling and the outcome, and pass the link along for a person to open.
What if a module fails halfway through?
Make stops that run and logs it in the execution history. The call itself is untouched in your GreetKeeper log, so you can fix the module and re-run.
Bring your routing rules
We will map them to a scenario live. Two minutes.