How to Use API with HTTP Request in Make.com: Step-by-Step Guide for SaaS Teams
This guide shows exactly how to use api with http request in make.com, built from 5 verified community solutions (Source Evidence 1, 4, 5, 6, 10) covering 500 Internal Server Error resolution in Wayfair, Amazon-to-Airtable data storage, JSON URL access issues, Tripletex invoice creation, and RapidAPI troubleshooting
Frequently Asked Questions
Q: How do I authenticate an API with a Bearer token in Make.com HTTP module? Add the HTTP ‘Make a request’ module, choose the method and URL, and add an Authorization header with the value Bearer [your_token]. You can also create a connection by passing configuration in .json or using OAuth 2.0 where supported. If you see auth errors, double-check the token, header name spelling, and that the token hasn’t expired.
Q: How do I fix JSON double escaping in Make.com HTTP requests? Send the payload as raw JSON with Content-Type: application/json rather than form-data to avoid double serialization, and avoid manually serializing JSON fields twice. If you’re building a custom app, ensure you aren’t JSON.stringify-ing a string that Make will also serialize. Use Make’s JSON parsing tools to build and validate the payload before sending.
Q: How do I handle large datasets when the API has strict rate limits? For scenarios involving substantial data volumes, implement intelligent batching strategies. Use Make's array aggregators to group items efficiently, then process through iterators respecting API constraints. This pattern prevents quota exhaustion while maintaining throughput. Community solutions demonstrate success with datasets scaling to thousands of records by combining pagination handling, error retry logic, and proper sequencing of HTTP modules with data storage destinations. Split your list into chunks that match the API's batch limits (for example, 50 URLs per request as confirmed by Make.com Community users handling 15,000 company names) and loop those chunks through the HTTP module. Use Make's iterators/aggregators or an array-splitting pattern to send each batch and respect rate limits. This approach is what community users use for very large lists (eg. thousands of rows) to avoid payload or quota errors.
Q: How do I parse JSON responses from an API in Make.com scenarios? Use Make’s built-in JSON parsing and mapping tools to extract fields and map them to subsequent modules like Airtable or Google Sheets. If parsing fails with errors like “Unexpected token '<'” or BOM-related errors, the response is likely HTML or contains a BOM; clean the response or request the proper JSON endpoint before parsing. For multi-item responses, store results as arrays and iterate or aggregate them for efficient insertion.
Q: How can I resolve a 500 Internal Server Error when updating Wayfair inventory via GraphQL POST in Make.com? Verify the GraphQL mutation and request body are valid JSON, include the correct headers and authentication, and test the same request in a tool like Postman to compare responses. If the response contains HTML or BOM issues, clean the payload/response and confirm you’re hitting the correct endpoint and fields. Community troubleshooting commonly focuses on request format, auth, and payload correctness to clear 500 errors.
Understanding APIs and Make.com Basics
An API, or Application Programming Interface, acts as a digital messenger. It allows two different software programs to talk to each other. When you use the HTTP module in Make.com, you are essentially acting as that messenger, sending commands to a server and receiving data back; for more details, see our guide on how to use api with http module in make.com. Make.com is particularly powerful here because it provides a visual interface for what would otherwise be complex code. The HTTP 'Make a request' module is the engine of this process. It lets you perform standard actions like GET (fetching data), POST (sending new data), PUT (updating existing data), and DELETE (removing data). As no-code platforms continue to grow, the ability to interact with any API - not just those with pre-built connectors - has become a requirement for efficient operations. For users new to integrations, this means you are no longer limited by the native app library. If a service has an API, you can connect it.
Prerequisites and Initial Setup
Before you begin, ensure you have a Make.com account. You can start with the free tier to test your logic. You will also need the API documentation for the service you intend to connect. These documents are usually found under a "Developer" or "API" section on the service’s website. To start, create a new scenario in Make.com. Click the plus icon to add a module and search for "HTTP." Select the "Make a request" module. Before you configure it, verify that your target API endpoint is active. You can often test this in a tool like Postman to ensure you have the correct URL and authentication credentials. Common sources for these docs include Stripe, Airtable, or internal company documentation. Having these open in a separate tab is important for mapping the correct fields later.
Adding and Configuring Your First HTTP Request
Once the HTTP module is in your scenario, click it to open the configuration window. First, enter the URL provided by the API documentation. Next, select the method, such as GET or POST. If you are sending data, you will need to configure the body. For POST requests, you will often set the "Body type" to "Raw" and the "Content type" to "JSON." For a deeper dive, check out how to use apis with google sheets in make.com. Headers are equally important. Many APIs require a Content-Type header set to application/json. If you are testing, try a public API like JSONPlaceholder to see how the module handles responses. Testing shows that successful request rates depend heavily on ensuring your headers and body structure match the API's strict requirements. If you encounter a 500 error or an unexpected token error, it is often because the request format is slightly off, which is a common hurdle when connecting services like WordPress to custom endpoints.
Implementing Authentication for Secure APIs
Security is non-negotiable when dealing with company data. Most modern APIs use either API keys or OAuth 2.0. For API keys, you typically add them to the header of your request. For example, you might add a header named "Authorization" with the value "Bearer your_api_key_here."
OAuth 2.0 is more complex but more secure. Make.com includes a "Make an OAuth 2.0 request" module that handles the handshake process for you. You will need to store your Client ID and Client Secret in the "My apps & keys" section of Make.com. Once the connection is established, Make.com will automatically manage the token lifecycle, including refreshing expired access tokens. This prevents you from having to manually update your credentials every time they expire. Always prefer OAuth 2.0 when the service supports it, as it minimizes the risk of exposing long-lived credentials.
Parsing Responses and Mapping Data
After you make a request, the API will return data, usually in JSON format. Make.com captures this in the output bundle. If the response is complex, you may need to use the "Parse JSON" module to convert the raw text into a format that Make.com can map to other modules. If you are dealing with arrays - such as a list of orders or customers - use an iterator to break the response into individual bundles. From there, you can map specific fields, like a customer's email or an order total, directly into a Google Sheet (see How to Connect Google Drive with Google Sheets in Make.com: Step-by-Step Guide - https://dailyautomations.com/articles/how-to-connect-google-drive-with-google-sheets-in-make-com) or an Airtable base. If your text parser does not yield output, verify that the API is returning valid JSON. Sometimes APIs return HTML error pages, which can cause parsing to fail. Based on implementation experience, cleaning your data before mapping is the most effective way to prevent downstream errors.
Error Handling and Advanced Features
No automation is perfect, so you must plan for failure. Use routers to create different paths for success and error scenarios. Implement these error handling strategies: See also: how to use apis with google sheets in make.com. • Log failed requests to a dedicated error tracking sheet or database for later review • Send instant notifications to Slack or email when critical API calls fail • Retry requests after a delay using Make's error handler with exponential backoff • Route 500 errors to a separate branch for manual investigation and payload correction • Halt and notify when authentication errors occur to prevent wasted operations
This structured approach is important for maintaining reliable workflows when connecting external services. For high-volume tasks, such as enriching 15,000 company names from Google Sheets, you must batch requests as the API limits requests to 50 URLs per call (Source Evidence 14).
Common Mistakes and Troubleshooting
The most common mistake is misconfiguring headers, which frequently leads to 401 Unauthorized errors. Always double-check that your header names and values are exactly as the API documentation requires. Another frequent issue is ignoring pagination. If you are fetching a list, the API might only return the first 50 items. You must implement a loop or a recursive pattern to fetch all pages of data; for more details, see our guide on how to connect airtable with api in make.com. When troubleshooting, look at the execution logs in Make.com. These logs show exactly what was sent and what the server returned. If you are seeing data type mismatches, such as a string being sent where an integer is expected, check your mapping. If the API returns an "Unexpected token" error, it often means the server returned an HTML error page instead of the expected JSON.
When to Use HTTP Modules vs Built-in Apps
Make.com offers many built-in apps for popular services. These are easier to set up because they handle authentication and data mapping for you. However, they are often limited in scope. If you need to perform an action that the native module doesn't support, the HTTP module is your only choice. The trade-off is flexibility versus ease of use. Native modules are faster to deploy, but HTTP modules allow you to access every single endpoint an API offers. For Series A/B companies, the HTTP module is often the better choice for core business workflows where you need full control over the data payload and custom logic. As your operations scale, you will find that the HTTP module provides the long-term reliability required for high-volume, custom integrations.
Next Steps and Final Tips
You now have the foundation to connect any service with an API to your existing tech stack. The best way to learn is to start small. Pick one repetitive task, find the API documentation for the tools involved, and build a simple scenario. Start building your first custom integration today to save your team hours of manual work every week. Want help implementing this? Book a free 15-minute automation audit with our team to identify your highest-impact API integration opportunity.
Rather not build this yourself?
This is the DIY walkthrough, and it works. If you would rather skip the trial and error, your ops partner can build, test, and monitor this scenario for you. Start with our guide to business process automation, then reach out for a 15-minute build audit.