Make

Make (formerly Integromat) builds scenarios on a visual canvas rather than as a linear list of steps, which makes it the better of the hosted platforms once a workflow has real branching in it. The APIVerve module exposes the whole catalog as one module you configure per use.

APIVerve on Make

Connecting

Add a module, search for APIVerve, and create a connection when prompted. The connection is saved to your Make account and selectable from any scenario — you authenticate once, not per scenario.

The connection resolves to your account's primary API key. Sub-keys are rejected with a 401 and Sub-keys cannot be used for integrations, and rotating the key invalidates the connection for every scenario using it at once.

Configuring the module

Pick an endpoint from the dropdown and Make loads that endpoint's parameters. The list is generated from the live catalog, so new endpoints appear without the module being updated.

Parameters arrive pre-filled with the endpoint's published example. This is specific to Make — the module merges the same sample request shown on the endpoint's reference page into the field defaults. A freshly-added module is runnable immediately, which makes Run once a genuine one-click check that your connection works before you have mapped anything.

Replace the defaults with mappings from earlier modules as you build. Parameters with a fixed set of values render as dropdowns; list and object parameters take JSON.

Reading the response

The module returns the API's response with output fields generated from the endpoint's sample, so they are mappable before the scenario has run. Nested values are flattened — data with a location object inside it gives you data__location__city — and a Raw Data (JSON) field holds the whole data object as a string when you want to pass it on intact.

Branch on status, which is ok or error, rather than on the presence of a particular field.

The Make-specific parts

Routers are the reason to choose Make. Put one after the APIVerve module and each route gets its own filter on the response: valid business emails to Salesforce, valid personal ones to a nurture list, invalid ones to a review queue. The alternative on a linear platform is three separate workflows.

Iterators and aggregators turn a list into individual calls and reassemble the results. Iterate a spreadsheet's rows, call an endpoint per row, aggregate back into one bundle to write out in a single update. Note that this is genuinely one call per item — an iterator over 500 rows is 500 calls, and the module gives you no discount for the loop being tidy.

Error handlers attached to the module decide what happens on a failure: ignore and continue, break and retry later, roll back, or route to a handler branch. Worth setting deliberately on anything scheduled, because the default is to stop the scenario.

Data stores are Make's built-in key–value cache and the single most effective way to cut usage. If your scenario looks up the same domains, addresses or IPs repeatedly, check the store first and only call the API on a miss.

What it costs

Loading the endpoint list, loading parameters and inspecting outputs are free. Only an execution of the module costs a call, at that endpoint's rate — identical to calling it directly.

Make's own operation counting is separate from ours and the two do not line up: an iterator with 500 items is 500 APIVerve calls but potentially many more Make operations. Budget both.

Scheduling is where scenarios get expensive. Every 5 minutes is roughly 8,640 executions a month; every 15 minutes is about 2,880. Combine that with an iterator and the multiplication is easy to miss until the balance is gone. Turn on the usage alert in settings and check analytics after the first full day of a new scenario.

What to build

Batch enrichment on a schedule. Fetch rows → iterate → call the endpoint per row → aggregate → write back. Filter for unprocessed rows before the iterator, so a re-run does not pay for rows you already did.

Conditional routing on a validation result. Webhook in → validate → router → three destinations. The clearest fit for Make's model.

A multi-endpoint chain. Webhook with a URL → SEO scraper → sentiment analysis on the extracted text → store the result. Chaining works because each module's output is mappable into the next.

When it fails

Errors pass through with the API's own status and message, so error handling applies unchanged.

401 — the connection, not the scenario. The key was rotated, or a sub-key was used. Recreate the connection.

400 — a parameter is wrong and the message names it. On Make this is most often a mapping that resolved to empty on that particular run. The execution history shows the exact input bundle for every module, which is the fastest way to see what was actually sent.

429 — the rate limit, or no calls left. An iterator is the usual cause: Make runs iterations back to back with no pacing, so a 500-row loop will outrun a per-minute ceiling well before it runs out of balance. Check the balance first; if there is balance, add a sleep module inside the loop or raise the plan.

A module times out. Connector calls are cut off at 25 seconds. Screenshot, PDF and rendering endpoints can exceed that on a heavy page — use the HTTP module for those and set your own timeout.

Parameters look ignored. For endpoints that accept POST, the connector sends a POST only when at least one parameter has a value, and otherwise falls back to a GET. A run where every mapping resolved to empty behaves differently from one where they did not.

Next

n8n is the self-hosted equivalent and reaches more than just the APIs, viaSocket is the lighter-weight option, and all endpoints is the catalog behind the dropdown. Integrations compares all of them side by side.