How do I call Loop from Make?

Use the HTTP > Make a request module. Set Method to GET, URL to https://api.stayinloop.dev/v1/search, and add q and location as Query String parameters. For POST calls like report(), set Method to POST, Body type to Raw, Content-Type to application/json, and write the JSON body using IML expressions to map values from prior modules.

How do I iterate over Loop search results in Make?

Connect an Iterator module after the HTTP module. Enable Parse response: Yes in the HTTP module, then set the Array field to {{N.data.results}} where N is the HTTP module's sequence number in your scenario. Inside the iterator, each item exposes fields like {{item.result_id}}, {{item.name}}, {{item.address}}, {{item.confidence}}, {{item.restaurant.vegan}}, and {{item.restaurant.outdoor_seating}}.

How do I use Loop with AI agents from Make?

Make acts as an MCP server — it exposes your scenarios as tools that AI agents can call. Build a scenario that calls Loop's REST API, set its scheduling to On-demand, and activate it. Get an MCP token from Profile > API Access. Any MCP-compatible AI client (Claude, ChatGPT, Cursor) can then call this scenario as a named tool via your Make MCP token URL.

Can I call Loop's MCP server directly from Make?

Make does not expose a built-in MCP client module in the scenario builder — to call Loop, use the HTTP module to reach Loop's REST API (api.stayinloop.dev/v1) directly. The REST and MCP interfaces expose the same four tools and data.

guide Make · HTTP module · MCP Server

Use Loop with Make.

Call Loop's REST API from an HTTP > Make a request module for automation pipelines, or expose a Loop-powered scenario as a tool AI agents can call via Make's built-in MCP Server. No key required in the free tier.

option 1 HTTP module + Iterator (automation pipeline)

The standard Make pattern: a trigger fires, an HTTP > Make a request module fetches results from Loop, and an Iterator module loops over the results array so downstream modules (email, Slack, database) can act on each one. Use this when the query and location are fixed or come from an upstream module.

Scenario: Trigger → HTTP (GET /v1/search) → Iterator (loop results) → downstream modules

HTTP module + Iterator config

// HTTP > Make a request — GET /v1/search
// Method:       GET
// URL:          https://api.stayinloop.dev/v1/search
// Query String:
//   q        = {{query}}   ← map from a prior module or type a literal
//   location = Kreuzberg, Berlin
//   limit    = 5

// Parse response: Yes   ← required; exposes .data as parsed JSON

// Iterator module — loop over results
// Array:  {{1.data.results}}   ← 1 = sequence number of the HTTP module

// Inside the iterator, each item exposes:
//   {{item.result_id}}
//   {{item.name}}
//   {{item.address}}
//   {{item.confidence}}
//   {{item.restaurant.vegan}}
//   {{item.restaurant.outdoor_seating}}
//   {{item.observed_at}}

To report an outcome, add a second HTTP module with Method POST. Map result_token from the module that called /v1/details/ and outcome from the downstream action:

HTTP module — POST /v1/report

// HTTP > Make a request — POST /v1/report
// Method:       POST
// URL:          https://api.stayinloop.dev/v1/report
// Body type:    Raw
// Content type: application/json
// Body:
{
  "result_token": "{{N.data.result_token}}",
  "outcome":      "{{N.outcome}}"
}

// outcome must be one of:
//   correct · wrong · booked · closed · other
// Map result_token from the HTTP module that called get_details (.data.result_token).

option 2 Make MCP Server (AI agents call your scenario as a tool)

Make can act as an MCP server — it exposes your active, on-demand scenarios as tools that any MCP-compatible AI agent can call. Build a scenario that wraps Loop's REST API, set it to on-demand, and activate it. The AI agent calls Make; Make calls Loop and returns the results.

Note: Make is the MCP server— AI agents call Make, not the other way around. Make does not expose a built-in MCP client module in the scenario builder; use the HTTP module to reach Loop's REST API directly.

Make MCP Server — expose scenario as AI tool

// Expose this scenario as a tool AI agents can call:
//
// 1. Replace or supplement the trigger with an On-demand schedule:
//    Scenario → Scheduling → On-demand → Activate
//    The scenario now appears in your Make MCP tool list.
//
// 2. Get your MCP token:
//    Profile (top-right) → API Access → MCP Token → Create
//    Token URL format:
//      https://<your-zone>/mcp/u/<MCP_TOKEN>/stateless
//    Example zone: eu2.make.com
//
// 3. Add to any MCP-compatible AI client:
//    Claude desktop  → mcp.json   → { "url": "<token-url>" }
//    Cursor          → Settings → MCP → add <token-url>
//    ChatGPT action  → type: "mcp", server_url: "<token-url>"
//
// The AI agent calls Make → Make calls Loop REST API → result returned.
// Scope to a single scenario by appending ?scenarioId=<id> to the URL.

API key (optional): Free tier — 30 reads/min, no key required. To get 60 reads/min and appear named on the signals board, add an Authorization header with value Bearer sk_live_…in the HTTP module's Headers section.

Make expression syntax (IML): Map values between modules using double-brace expressions: {{N.data.results}} where Nis the source module's sequence number (requires Parse response: Yes in the HTTP module). Inside an Iterator, use {{item.field}} for each element. For n8n users: {{1.data.results}} is Make's equivalent of n8n's $input.first().json.results.

← Full API reference Watch your calls on the signals board →