Integration · Automate and collaborate

Make and Meteor AI agents

Connect Make to a Meteor AI agent: run your scenarios from WhatsApp and check whether they finished well, with 8 official tools.

Book a demo See every integration

How does Make connect to Meteor?

With Make connected, your WhatsApp Met runs the scenarios you already built in Make when the conversation calls for it, for example when an order is confirmed or a request arrives, and passes them the details the customer gave. It then checks the execution history to know whether the scenario finished well and, if it failed, in which module. Make's official server gives it 8 tools to list, open, activate and run scenarios and to read their executions. Each run uses credits from your Make plan.

What it automates

What a Meteor Met does with Make

Trigger a scenario when the customer confirms

When the customer confirms an order on WhatsApp, your Met runs the Make scenario that records it in your systems, with the name, product and address they gave in the chat.

Know whether the scenario finished well

If the run takes a while, your Met keeps its ID and checks the result later, instead of assuming it failed or succeeded.

Find where it broke

When a run fails, your Met checks which module raised the error and tells your team in the internal chat, with the message Make returned.

8 tools

Everything your Met can ask Make for

Each one is a real action in the connector. You can switch off the ones you would rather it never used.

Tool	What it does
`scenario_list`	Lists the scenarios in your Make account, up to 25 per query, most recent first.
`scenario_get`	Opens a scenario and tells how it starts, what inputs it takes and whether any module has errors.
`scenario_activate`	Activates an inactive scenario so it can run.
`scenario_run`	Runs a scenario; if it is on demand, it passes the inputs and returns its output.
`scenario_execution_list`	Lists a scenario's executions, with the error message of the ones that failed.
`scenario_execution_get`	Brings the result of an execution, its output and the credits it used.
`scenario_execution_inspect`	Shows the status of an execution and each module that ran, with its errors.
`scenario_trigger_inspect`	Checks a scenario's webhook and how many requests are queued unprocessed.

The limits

What the Make integration does NOT do

We would rather say it here than have you find out during rollout.

It does not run a scenario that starts from a webhook. For those, Make returns the webhook address and the scenario runs when a real request arrives.
It does not create or edit scenarios in this listing. The tools listed run, activate and review scenarios that already exist in your account.
It does not ask for confirmation in the chat before running. The workspace admin chooses which actions stay on.
It does not wait more than a few seconds. With OAuth, Make cuts the call at 25 seconds; the scenario keeps running for up to 40 minutes and the result is checked later with its ID.
Your company pays for Make usage under its plan: each run uses credits. Met does not charge Energy for these calls.

Before you start

What you need to connect Make

1

A Make account on a paid plan to review scenarios

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

On demand scenarios with defined inputs

For the Met to pass data to a scenario, the scenario must start on demand and declare its inputs in Make. If it declares none, Make ignores the data.
3

Connect it in Met

In Met, go to Connections, search for Make and tap Connect. The Make window opens, you sign in, choose the permissions and approve access.

Frequently asked questions

Questions about Make and Meteor

Make rejects it and says it has to be activated. New scenarios start inactive; if activation fails, it is almost always because a module has a configuration error.

If the response stays pending, the Met checks the execution with the ID Make returned. A pending run is not a failure: it only took longer than the call's wait.

Yes. When connecting, you choose the permissions in the Make window, and those permissions decide which tools appear. If Make answers that permission is missing, the whole connection has to be authorized again.

Your company, under its Make plan. Each run spends credits based on the modules that run, and checking an execution shows how many it used.

Step by step