Automation · Orders and fulfillment

Run a Make scenario when an order is confirmed on WhatsApp

An AI agent runs your Make scenario when the customer confirms an order on WhatsApp and checks that the execution finished well.

Show me this with my own operation See every automation

How do I make an order confirmed on WhatsApp reach my systems on its own with Make?

A Met connected to Make takes the order the customer confirmed on WhatsApp and runs the Make scenario your team already built to record it, for example in your store, your order sheet or your shipping system. First it checks which inputs the scenario needs and whether it is active. After running it, it checks the result with the ID Make returns and only confirms to the customer what Make reports as finished. If the run fails, it finds the module that raised the error and tells your team.

What starts it

When the customer writes

It starts when the customer confirms an order on WhatsApp with product, quantity and delivery details. There is no trigger to configure: the Met assigned to the line runs the procedure inside that conversation.

Nothing to set up. The Met assigned to that channel picks up the conversation and runs the procedure inside it.

Who runs it

Sales Met that closes orders

This is not a named, seeded Met. It is the Met that already sells on the company's WhatsApp, with Make connected. Its work ends when the confirmed order was recorded by the scenario and the customer has a confirmation that matches what happened.

Run by the sales closing Met

Channels: WhatsApp

What you need connected

Make Automate and collaborate

6 steps · 7 tools

The procedure, step by step

Each step shows the tool that runs. They belong to the real connector: if one of them stopped existing, this page would not build.

1
Find the orders scenario

The Met lists the scenarios in your Make account and takes the one your team named for recording orders. The list brings up to 25 per query, most recently edited first; that is why the scenario name goes in the Met's instructions.
- scenario_list Make
2
Check its inputs and how it starts

The Met opens the scenario to see whether it starts on demand and which inputs it declares, such as name, product, quantity and address. If the scenario starts from a webhook, it does not run it: Make would only return the webhook address and nothing would run.
- scenario_get Make
3
Activate it if it is inactive

If Make says the scenario is inactive, the Met activates it. If activation fails, a module almost always has a configuration error: the Met does not insist and alerts your team, because the order cannot go in that way.
- scenario_activate Make
4
Run it with the order details

The Met runs the scenario with the inputs it declares, using the exact names Make expects and the values the customer confirmed. If Make rejects an input, it reads the message naming the right interface instead of guessing again.
- scenario_run Make
5
Confirm the result before replying

With OAuth, Make cuts the call at 25 seconds and the scenario can keep running. The Met keeps the execution ID, checks its result and reviews the history; only when Make marks it finished does it confirm the order to the customer.
- scenario_execution_get Make
- scenario_execution_list Make
6
Find the module that failed

If the run ended with an error, the Met checks which module raised it and with what message, and tells your team in the internal chat. It tells the customer their order is under review, without confirming something Make did not record.
- scenario_execution_inspect Make

Before you start

What you need ready

The Met solves none of these for you. If one is missing, the automation stops there.

Make connected in Met

In Met, go to Connections, search for Make and tap Connect. In the Make window you sign in and choose the run and management permissions.
An on demand scenario with declared inputs

Your team builds in Make the scenario that records orders, sets it to start on demand and declares its inputs. Without declared inputs, Make ignores the order details.
A paid Make plan to review executions

Listing, opening, activating and reviewing executions are management tools, and Make keeps them for paid plans. Running scenarios is on every plan.

The limits

What this automation does NOT solve

Better said here than discovered halfway through the rollout.

It does not build the scenario. If the orders scenario does not exist or has errors, the Met does not create or fix it in this automation.
It does not charge for the order. Recording the order is whatever your scenario does; payment goes another way, such as a payment link.
It does not ask for confirmation before running. The control is which actions the workspace admin keeps on and what the scenario does.
It does not work for scenarios that start from a webhook or a schedule: those do not receive the order inputs from the Met.

FAQ

Questions about this automation

It is not a failure: it only took longer than the call's wait. The scenario keeps running for up to 40 minutes and the Met checks the result with the execution ID.

It can, if it runs the scenario again. That is why it checks the result before retrying, and your scenario should check whether the order already exists.

Whatever your scenario's modules use. Checking the execution shows the credits used, so your team can see them order by order.

Because Make does not run a webhook scenario from this tool: it returns the webhook address. For this automation, the scenario must start on demand.

Keep going