To send an API request with an HTTP module, copy the endpoint’s exact requirements into the module: URL, HTTP method, authentication, query parameters, headers, body format and body data. In Make, use the HTTP app’s Make a request module, run it once, and inspect the status code and response before mapping data into later steps. The API documentation—not a generic template—decides which values belong in each field.
What an HTTP API request contains
A complete request has four core pieces: URL, method, headers and body. Authentication and query parameters are commonly added as separate configuration fields. The server returns an HTTP status code plus response data, usually JSON.
- URL: the endpoint, such as
https://api.example.com/v1/orders. - Method: the operation the endpoint expects.
- Headers: metadata such as content type, accept format or a required tenant identifier.
- Query parameters: values appended to the URL, often used for filtering, fields, limits or page cursors.
- Body: data sent with methods such as POST, PUT or PATCH.
- Authentication: an API key, Basic Auth, OAuth 2.0 token or another scheme specified by the service.
Never assume that an example for one endpoint applies to another. Check the target endpoint’s documentation for its exact method, parameter spelling, required headers, body schema and response format.
How to send the request in Make
1. Read the endpoint documentation first
- Write down the complete HTTPS endpoint URL.
- Confirm whether it requires GET, HEAD, POST, PUT, PATCH, DELETE or OPTIONS.
- Record required authentication and where the service expects it.
- List query parameters, headers, required body fields and the accepted content type.
- Note the success and error response shapes, including pagination instructions.
Use the endpoint’s own example as a checklist, but verify every value against the endpoint you are calling.
Do these 3 things before closing this tab:
1Repair Windows errors before they cause bigger problems2Fix the driver behind crashes, sound loss and screen glitches3Clear out junk files and repair common Windows errors#1 Best Overall
2. Add the HTTP module
Create or open a Make scenario, select the HTTP app, and choose Make a request. Start with the complete endpoint URL. Make does not accept unverified self-signed certificates, so use a certificate that the platform can verify.
3. Choose the method
Select the method required by the endpoint:
| Method | Typical purpose |
|---|---|
| GET | Retrieve data |
| HEAD | Check status and headers without requesting a response body |
| POST | Create a resource or trigger an operation |
| PUT | Replace a resource |
| PATCH | Partially update a resource |
| DELETE | Delete a resource |
| OPTIONS | Ask which operations or request details are available |
These are the meanings supported by Make’s control, but the endpoint specification remains decisive.
4. Configure authentication safely
Choose No authentication only for an endpoint that truly requires none. Otherwise select the API key, Basic Auth or OAuth 2.0 option that matches the service. Put secrets in Make’s dedicated Credentials field. Make’s security guidance is explicit: define authentication there instead of passing secrets through ordinary headers or query parameters.
Some APIs require a bearer token in an authorization header, while others require a named key or signed request. Do not invent a header name or move a credential to the query string unless the API documentation says to do so.
Recommended Free Tools
5. Add query parameters and headers
Enter each query parameter in Make’s query-parameters area as a key/value pair. Add only headers the endpoint requires, such as Accept, an idempotency key or a vendor-specific version header. Use Make’s authentication and content-type controls when available instead of duplicating those values as generic headers.
Rank #2
- Used Book in Good Condition
6. Select the body format
For requests with a body, select the encoding the endpoint expects:
- JSON: use for APIs documented with an application/json body.
- multipart/form-data: use for file uploads or mixed fields and files.
- URL-encoded form: use when the endpoint specifies form fields encoded as a query-string-style body.
- Custom content type: use for XML or another explicitly documented media type.
When sending JSON, a Make data structure is safer for mapped values because reserved characters are escaped automatically. If you enter a raw JSON string, it must be valid JSON and you must escape quotes, backslashes and other reserved characters yourself.
7. Parse and test the response
Enable response parsing when you need structured fields in later modules. Run the module once; Make then exposes the returned structure for mapping. Inspect the HTTP status, response headers and body. A successful transport response does not necessarily mean the business operation succeeded, so read any status or error object in the returned data.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
You can configure Make to stop the scenario when an HTTP request returns a 4xx or 5xx status. This prevents later modules from processing an error response as if it were valid data.
Methods, bodies and examples
GET with query parameters
For a collection request, place filters such as status=paid or limit=50 in query parameters. A GET normally has no body unless the API explicitly documents one.
POST with JSON
Select POST, choose JSON, and map the required fields into the documented object. Keep field names and nesting exactly as shown by the API. A missing required property, wrong data type or incorrect content type commonly produces a validation error.
PUT and PATCH updates
Use PUT only when the endpoint defines replacement semantics. Use PATCH for the partial-update schema it documents; some services require an operation list rather than a simple object.
Quick wins for a faster PC:
Fix the driver behind crashes, sound loss and screen glitchesFind Drivers →Clear out junk files and repair common Windows errorsFree Scan →DELETE and idempotency
Confirm whether DELETE needs a body, an identifier in the path or an idempotency key. Test against a safe record first, because retrying a state-changing request can have consequences.
Pagination: getting the whole collection
A successful first response may contain only one page. Read the API’s pagination contract and configure Make accordingly. Supported patterns include:
- Offset/limit: increase an offset until the response contains no more records.
- Page number: increment the documented page parameter.
- Next-page URL: request the URL returned by the server.
- Cursor or token: send the returned cursor on the next request.
Do not substitute a page-number loop for a cursor API. In n8n, the HTTP Request node can update a parameter or follow a next-page URL; Make provides offset, page, URL/link and cursor/token pagination settings.
How n8n and Zapier differ
| Platform | Configuration | Distinctive control |
|---|---|---|
| Make | HTTP app, Make a request | Dedicated credentials, multiple body types, response parsing and native pagination |
| n8n | HTTP Request node | Can import a cURL example; importing overwrites the node’s existing configuration |
| Zapier | API Request action or API by Zapier | Connected-account authentication is added automatically; API by Zapier availability and paid-plan eligibility can change |
n8n’s official guidance describes the HTTP Request node as a way to query any app or service with a REST API. Zapier documents sending GET, POST, PUT, PATCH or DELETE requests with optional query parameters, headers and a body. Their field labels and credential flows differ from Make, so follow the selected platform’s UI.
Troubleshooting common failures
401 or 403 authentication errors
Check that the credential type, token scope and placement match the API guide. Reconnect or replace the stored credential if it is expired. Do not paste a secret into an arbitrary header when the platform offers a credentials field.
400 or validation errors
Compare the method, URL path, required fields, spelling, nesting, data types and content type with the endpoint example. If you used raw JSON, validate its syntax and escaping. A Make JSON data structure reduces escaping mistakes.
Expected fields are missing
Turn on response parsing and run the module once so Make learns the output structure. Then inspect the raw response for an error object, an alternate nesting level or a field omitted by an API permission.
The list is incomplete
Inspect the response for a next URL, cursor, page number or total count and configure the matching pagination scheme. A limit parameter alone does not guarantee that all records are returned.
Free tools Windows power users keep installed
One-click scans. No signup required.
Best Value
Redirects change the result
Redirect handling can change the method or discard a body. Make documents that 303 responses can switch methods and that POST requests redirected with 301 or 302 may lose their body. For state-changing calls, verify the final destination and redirect behavior.
Timeouts and slow responses
Make documents an HTTP timeout range of 1–300 seconds. Set a timeout appropriate to the endpoint, but first fix slow queries, oversized responses or an unreliable upstream service. Use pagination and narrower field selections where the API supports them.
Or skip the browser setup
If your API workflow needs a website screenshot rather than a data response, ScreenshotNeo provides a single-call screenshot API and MCP server. It accepts cookie or consent banners as a visitor and removes more than 60 known consent platforms, newsletter popups and chat widgets before capture; each cleanup step can be disabled. Bot checks, CAPTCHAs, blank pages, timeouts, failed loads and cache hits are not billed, and the response identifies the page verdict and billing result in headers.
Use the API directly (see the ScreenshotNeo documentation):
curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://stripe.com -o shot.webpPython:
import requests
r = requests.get("https://api.screenshotneo.com/v1/shot", params={"access_key": "YOUR_API_KEY", "url": "https://stripe.com"}, timeout=90)
open("shot.webp", "wb").write(r.content)Node.js:
const q = new URLSearchParams({ access_key: 'YOUR_API_KEY', url: 'https://stripe.com' });
const res = await fetch(`https://api.screenshotneo.com/v1/shot?${q}`);ScreenshotNeo also offers an MCP server with take_screenshot, get_page_info and capture_pdf for Claude, Cursor and other MCP clients. The Free plan includes 1,000 screenshots per month with no card; paid plans start at $5 for 3,000 shots. Create a free ScreenshotNeo account.
Frequently Asked Questions
How do I call an API without writing code?
Use an automation platform’s HTTP module or node, such as Make’s HTTP app, n8n’s HTTP Request node or Zapier’s API Request action. You still need the endpoint documentation to supply the correct URL, method, credentials and data.
How do I authenticate an API request?
Select the credential type required by the endpoint and store the secret in the platform’s dedicated credential control. Only place a key in a header or query parameter when the API explicitly requires that location.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
