How to Call Any API in Make With the HTTP Module

A practical field guide from Automation Ace.

The short answer

First check whether the app's own Make integration has a Make an API Call module, which reuses the existing connection. If not, use the HTTP app. Pick the request module that matches the API's authentication, store credentials in a keychain or connection rather than in plain fields, and build JSON bodies with the Create JSON module instead of typing them. Turn on response parsing, treat non-2xx responses as errors, and add a Repeater or loop for paginated results.

Before you start

• Read the API docs for the endpoint: method, URL, required headers, body format, authentication, rate limits, and pagination.
• Check for a Make an API Call module in the app's integration. It uses the app connection you already have, so you skip setting up authentication.
• Test the call outside Make with the API's examples first, so you know what a working request looks like before mapping data into it.

For background, see APIs vs webhooks and API authentication for automation.

Pick the right HTTP module

Module names and options change over time, so check the current HTTP app in Make. For API keys, store the key in a keychain or credential field if your plan supports it, rather than pasting it into headers in each scenario.

Build the request

1. URL and method: paste the endpoint and choose GET, POST, PUT, PATCH, or DELETE.
2. Headers: add what the API requires, such as Authorization: Bearer <token> and Accept: application/json.
3. Query string: add filters and paging parameters as separate items so Make encodes them correctly.
4. Body: for JSON APIs, choose a raw body with the JSON content type. Build the body with the JSON → Create JSON module and map its output, so quotes and line breaks in your data are escaped.
5. Parse response: turn it on so later modules can map individual fields.

Typing JSON by hand with mapped values is the most common cause of 400 errors. See why an API call returns 400 Bad Request.

Handle pagination

Many APIs return results in pages. Common patterns in Make:

• Page numbers: use a Repeater to run the HTTP module for page 1, 2, 3 and so on, and stop with a filter when a page comes back empty.
• Cursors or next links: store the cursor from each response with a variable or data store, and request the next page until no cursor is returned.
• Large result sets: process pages in batches across several runs instead of one long run. See processing large lists in Make.

Combine page results with an aggregator if later steps need one list. See Make iterators and aggregators.

Handle errors and rate limits

• Turn on the option to treat non-2xx responses as errors, so a failed call doesn't look like a success.
• Add an error handler on the HTTP module: retry temporary errors such as 429 and 5xx, and alert someone for 400, 401, and 403 errors that need a fix.
• Add a Sleep module or slow the schedule when you hit rate limits. See 429 rate limit errors.
• Log the request ID and status code for failed calls so you can trace them later.

See Make scenario error handling, 401 errors, and 403 errors.

Example: create a record in an internal API

A team needs to create orders in an internal system that has no Make integration. The scenario receives a form submission by webhook, builds the order body with Create JSON, and sends it with an HTTP request that includes an API key header from a keychain. It parses the response to get the new order ID and writes that ID back to the CRM. An error handler retries temporary failures and posts to Slack when the API rejects the data. See Make webhook automation examples for the receiving side.

Frequently asked questions

When should I use the HTTP module instead of an app module?

Use an app module or its Make an API Call module when one exists, because it reuses the connection and handles authentication. Use the HTTP module when the app has no Make integration or the endpoint you need is not available.

How do I send JSON from Make without errors?

Build the body with the Create JSON module and map its output into a raw JSON body. That escapes quotes, line breaks, and special characters that break hand-written JSON.

How do I handle API pagination in Make?

Use a Repeater for page numbers, or store the next cursor and request pages until none is returned. Stop with a filter on an empty page, and aggregate the results if later steps need one list.

How should I store API keys in Make?

Use a keychain, credential field, or app connection where your plan supports it, rather than pasting keys into each module. Limit who can edit scenarios that use them.