Make.com HTTP Module: Call Any REST API From Your Scenario

Contains affiliate links. Disclosure.

The Make.com HTTP module lets you call any REST API directly from your scenario — no dedicated connector needed. If an app exposes an HTTP endpoint, the HTTP module reaches it. GET, POST, PUT, DELETE, file downloads, OAuth handshakes, and paginated data dumps are all first-class operations.

This tutorial covers every HTTP module variant, walks through request configuration in detail, and finishes with three production-ready examples that show exactly how the module behaves under real-world conditions.

What is the Make.com HTTP module?

Make.com ships with over 3,000 pre-built app connectors. But every API that doesn't have a connector — or where the connector doesn't expose the endpoint you need — is still reachable through the HTTP module.

The HTTP module is a generic REST client embedded directly in the Make scenario builder. You pick your method, supply a URL, configure headers and a body, and map the JSON response into downstream modules. No code. No custom app build required.

When to use the HTTP module instead of a dedicated connector:

Situation	Use HTTP module
The app has no Make connector	✅ Yes
The connector exists but misses a specific endpoint	✅ Yes
You're testing an API before building a full integration	✅ Yes
You need fine-grained control over headers and body	✅ Yes
Standard connector covers your full use case	❌ Use connector instead

---

The five HTTP module variants

Make ships five distinct HTTP modules, each targeting a different authentication pattern:

1. Make a Request

The baseline module. You manage authentication manually by injecting tokens or API keys into headers or query parameters yourself. Best for Bearer token APIs and custom auth schemes.

2. Make a Basic Auth Request

Automatically encodes a username:password pair as a Base64 Authorization: Basic <token> header. Use this for any API that uses HTTP Basic Authentication.

3. Make an API Key Auth Request

Attaches a pre-configured API key to every request, either as a header (X-API-Key, Authorization, etc.) or as a query parameter. You define the key name and value once in the connection, then reuse across multiple modules.

4. Make an OAuth 2.0 Request

Handles the full OAuth 2.0 flow: client credentials exchange, access token storage, and automatic token refresh when the token expires. Required for Google APIs, Salesforce, HubSpot, and any other service using delegated authorization.

5. Get a File

A specialized GET request that downloads a binary file and passes it to the next module as a Make file bundle (processable by Archive, Google Drive, Dropbox, etc.).

---

Configuring a request: field-by-field

Open any HTTP module and you'll see the same configuration panel. Here's what each field does.

URL

The full endpoint URL. Supports Make's dynamic mapping — you can insert output bundles from previous modules using the mapper panel:

https://api.example.com/v1/users/{{1.userId}}/orders

Tip: Never hardcode IDs or tokens directly in the URL. Map them from earlier modules or from a dedicated Data Store module so you can update them without touching the scenario.

Method

Select GET, POST, PUT, PATCH, DELETE, or HEAD. Make uses this to set the HTTP verb on the outgoing request.

Headers

Add custom request headers as key-value pairs. Common headers:

Header	Example value
Content-Type	application/json
Authorization	Bearer {{connection.token}}
Accept	application/json
X-API-Key	{{1.apiKey}}

You do not need to add Content-Type: application/json manually if you select the JSON body type — Make sets it automatically.

Query String

Key-value pairs appended to the URL as query parameters. Equivalent to writing ?key=value&key2=value2 in the URL, but cleaner and easier to Map dynamically.

Body Type

Controls how the request body is serialized:

Body type	Use case
Raw	JSON, XML, or any free-form text body
Application/x-www-form-urlencoded	HTML form submissions
Multipart/form-data	File uploads
None	GET, DELETE (no body)

For REST JSON APIs, use Raw with content type application/json, then paste or build your JSON payload using Map variables:

{
  "name": "{{1.contactName}}",
  "email": "{{1.email}}",
  "source": "make-scenario"
}

Parse Response

When checked, Make automatically parses the response body as JSON and exposes the fields for mapping in downstream modules. Always enable this for JSON APIs — without it, the response arrives as a raw string and you'd have to parse it manually with a JSON → Parse JSON module.

Timeout

Maximum seconds to wait for a response before treating the request as failed. Default is 40 seconds. Increase this for slow APIs; decrease it to fail fast in time-sensitive scenarios.

Follow Redirect

Follows HTTP 301/302 redirects automatically. Enable this unless you specifically need to capture the redirect URL itself.

Maximum number of results

Relevant only when you're iterating over paginated responses using an iterator loop (covered below).

---

Parsing JSON responses

When Parse Response is enabled, Make decomposes the API response into a structured bundle that downstream modules can access.

Consider this API response:

{
  "status": "ok",
  "data": {
    "user": {
      "id": 9823,
      "name": "Ada Lovelace",
      "email": "ada@example.com"
    },
    "orders": [
      { "id": "ord-001", "total": 149.99, "status": "shipped" },
      { "id": "ord-002", "total": 89.00, "status": "pending" }
    ]
  }
}

After parsing, the mapping panel exposes:

• {{1.status}} → ok
• {{1.data.user.id}} → 9823
• {{1.data.user.name}} → Ada Lovelace
• {{1.data.orders[]}} → array of order objects

To process each order individually, pipe the orders array through a Tools → Iterator module. Each iteration emits one order bundle, which you pass to a database insert or Slack notification as a separate execution step.

---

Handling pagination

Most real-world APIs don't return all results in a single response. They paginate. Make handles two common patterns.

Pattern 1: Page-based pagination (offset/limit)

The API uses page or offset + limit query parameters. Example: GitHub Issues API, Jira REST API.

Setup in Make:

1. Add a Set Variable module before the HTTP module, initializing page = 1.
2. In the HTTP module Query String, set page = {{variable.page}} and per_page = 100.
3. After the HTTP module, add a Router module.
4. In one router path: check if {{http.data.length}} == 100 (full page → more results exist). If true, use Set Variable to increment page by 1, then loop back using a Flow Control → Repeater module.
5. In the other path: stop when the response is shorter than the page size.

Pattern 2: Cursor-based pagination (next_cursor or next_page_token)

The API returns a cursor or token pointing to the next page. Example: Stripe API, Twitter API v2.

Setup in Make:

1. Make the first HTTP request normally.
2. Parse {{1.meta.next_cursor}} from the response.
3. Use a Flow Control → Repeater or recursive webhook pattern to feed the cursor back into the next HTTP request as a query parameter.
4. Stop condition: when next_cursor is null or absent in the response.

Pattern 3: Link header pagination

The API includes a Link: <url>; rel="next" header (GitHub, many REST frameworks). In Make, access response headers via {{1.headers.link}} and parse the next URL with a Regex or Text Parser module.

---

Authentication patterns

API Key in header

Use Make an API Key Auth Request. Configure the connection once:

• Key name: Authorization
• Key value: Bearer sk-abc123...
• Location: Header

All subsequent requests using this connection automatically include the header.

OAuth 2.0 (client credentials)

Use Make an OAuth 2.0 Request. Configure:

• Token URL: https://auth.example.com/oauth/token
• Client ID and secret from your OAuth app
• Scope (if required)
• Grant type: client_credentials

Make exchanges credentials for an access token on first run and refreshes it automatically when it expires.

OAuth 2.0 (authorization code)

For user-delegated flows (Google, Salesforce), use the same module but select grant type authorization_code. Make opens a browser popup on connection setup to complete the OAuth consent screen.

HMAC signature authentication

Some APIs (Shopify webhooks, GitHub webhooks) require HMAC-signed payloads. Compute the signature in a Tools → Set Variable module using Make's sha256 function, then inject it as a custom header:

X-Hub-Signature-256: sha256={{sha256({{1.rawBody}}, "your_secret")}}

---

Error handling

By default, if an HTTP module receives a non-2xx status code, Make stops the scenario and marks the run as an error. Two patterns let you handle errors gracefully.

Error route

Right-click the HTTP module in the scenario canvas and select "Add error handler". Choose "Resume" to continue the scenario with an empty bundle, or "Ignore" to silently swallow the error. Use the "Break" handler to queue the failed bundle for retry.

Within the error route, map {{1.statusCode}} and {{1.body}} to log the failure details to a Google Sheet, send a Slack alert, or trigger a retry webhook.

Conditional response checking

Even 200 responses can indicate logical failures (APIs that return {"success": false, "error": "not found"}). After the HTTP module, add a Router → Filter that checks {{1.success}} = true. Route failed responses to a separate error-handling branch.

Retry with exponential backoff

For rate-limited APIs (HTTP 429), configure a Flow Control → Sleep module before retrying:

1. Add an error handler set to "Break" on the HTTP module.
2. In the break route, add a Sleep module with duration {{power(2, attemptNumber) * 1000}} milliseconds.
3. Connect back to the HTTP module to retry.

Make's built-in "Retry" toggle on the error handler also handles simple retry logic without custom routing.

---

Practical example 1: Fetch GitHub Issues and log to Airtable

This scenario polls a GitHub repository for open issues and logs each one to an Airtable base.

Modules:

1. Schedule trigger — run every hour
2. HTTP: Make an API Key Auth Request
   • URL: https://api.github.com/repos/{{owner}}/{{repo}}/issues?state=open&per_page=100
   • Method: GET
   • Header: Authorization: Bearer {{your_github_token}}
   • Header: Accept: application/vnd.github+json
   • Parse Response: ✅
3. Tools: Iterator — iterate over {{2.[]}} (the array of issues)
4. Airtable: Create a Record — map {{3.title}}, {{3.html_url}}, {{3.user.login}}, {{3.created_at}}

Result: Every new issue on the repository becomes an Airtable record within an hour.

---

Practical example 2: POST to a webhook with dynamic JSON payload

This scenario listens for new rows in Google Sheets and POSTs structured data to a third-party analytics API.

Modules:

1. Google Sheets: Watch Rows trigger
2. HTTP: Make a Request
   • URL: https://analytics.example.com/api/v1/events
   • Method: POST
   • Body Type: Raw
   • Content Type: application/json
   • Body:

     {
       "event": "lead_created",
       "properties": {
         "email": "{{1.Email}}",
         "source": "{{1.Source}}",
         "timestamp": "{{now}}"
       }
     }

   • Header: X-API-Key: {{connection.apiKey}}
   • Parse Response: ✅
3. Router: check {{2.statusCode}} = 200 → success branch; else → Slack alert

---

Practical example 3: Pull paginated Stripe charges and summarize in Slack

This scenario retrieves the last 100 Stripe charges using cursor pagination and posts a daily summary.

Modules:

1. Schedule trigger — daily at 09:00
2. HTTP: Make an API Key Auth Request (Stripe connection)
   • URL: https://api.stripe.com/v1/charges?limit=100
   • Method: GET
   • Parse Response: ✅
3. Tools: Iterator — iterate over {{2.data[]}}
4. Aggregator: Numeric Aggregator — sum {{3.amount}} across all iterations
5. HTTP: Make a Request → POST to Slack webhook with:

   {
     "text": "Yesterday's Stripe revenue: ${{divide(4.sum, 100)}} across {{4.count}} charges."
   }

For deeper analysis, combine this with Apify's data extraction actors to correlate payment data with web-scraped competitor pricing or lead sources, then push the combined dataset into your BI tool via the HTTP module.

---

HTTP module vs. dedicated Make connectors

Criterion	HTTP module	Dedicated connector
Setup time	5–15 min per endpoint	1–3 min per action
Auth management	Manual or per-module	Connection stored once
Field discovery	Manual JSON parsing	Auto-populated dropdowns
New API versions	Always up to date	Depends on Make's update cycle
Unsupported endpoints	✅ Fully accessible	❌ Not available
Best for	Custom APIs, internal tools, gaps in connectors	3,000+ supported apps

Use the dedicated connector when one exists and covers your use case. Fall back to the HTTP module when the connector is missing or incomplete.

---

Connecting Apify to Make.com via the HTTP module

Apify exposes a full REST API for running actors, reading datasets, and managing storage. The HTTP module is an alternative to the dedicated Apify Make.com connector when you need fine-grained control.

Run an Apify Actor via HTTP module:

POST https://api.apify.com/v2/acts/%7B%7BactorId%7D%7D/runs?fpr=use-apify
Authorization: Bearer {{apify_api_token}}
Content-Type: application/json

{
  "startUrls": [{"url": "https://example.com"}],
  "maxCrawlDepth": 2
}

Retrieve dataset items:

GET https://api.apify.com/v2/datasets/%7B%7BdatasetId%7D%7D/items?format=json&limit=1000&fpr=use-apify
Authorization: Bearer {{apify_api_token}}

This pattern is useful for building agentic data pipelines where Make.com orchestrates Apify actor runs in response to triggers from CRMs, webhooks, or schedule-based events.

---

FAQ

How do I call an API in Make.com?

Add an HTTP → Make a Request module to your scenario. Set the URL to the API endpoint, select the HTTP method (GET/POST/PUT/DELETE), add any required headers (e.g., Authorization: Bearer your_token), configure the body for POST requests, enable Parse Response, and connect the output to downstream modules.

Can Make.com connect to any API?

Yes. The HTTP module works with any API that accepts standard HTTP requests. REST APIs, webhooks, and RPC-style JSON APIs are all supported. The only limit is Make's IP allowlist — some enterprise APIs restrict inbound calls to specific IP ranges. Make supports static IP allocation on paid plans to address this.

Which HTTP module should I use for API key authentication?

Use HTTP → Make an API Key Auth Request. Configure the key name, value, and injection location (header or query param) once in the connection. Reuse the connection across multiple HTTP modules in the same scenario without re-entering credentials.

How do I handle a 429 Too Many Requests error?

Right-click the HTTP module, add an error handler, select "Break", and add a Flow Control → Sleep module before retrying. Set the sleep duration to match the Retry-After header value from the API response: {{1.headers.retry-after * 1000}} milliseconds.

Does Make.com support GraphQL?

Yes. Set method to POST, body type to Raw, content type to application/json, and body to:

{
  "query": "{ users { id name email } }",
  "variables": {}
}

GraphQL over HTTP is indistinguishable from a standard REST POST request.

What is the maximum request timeout in Make.com?

The HTTP module timeout field accepts values up to 300 seconds (5 minutes). If the upstream API takes longer than that, consider triggering it asynchronously — fire a POST to start a job, then poll for completion in a separate scenario triggered by a webhook from the API.

Can I download a file from a URL in Make.com?

Use HTTP → Get a File. It performs a GET request and returns the response body as a Make file bundle compatible with Google Drive, Dropbox, Box, AWS S3, and archive modules.

---

Get started with Make.com

The HTTP module removes the "no connector" blocker from any API integration. Create a free Make.com account — the free tier includes 1,000 operations/month with no time limit, enough to test and iterate on any API integration before committing to a paid plan.

For larger-scale data pipelines where you need to extract web data and route it through Make workflows, pair Make with Apify's actor library to cover the data acquisition layer while Make handles orchestration, transformation, and delivery.