Documentation Python quickstart Blog Free tools Enterprise solutions hello@quanticdata.ioLog in

Calling an API from n8n, Azure Logic Apps and Power Automate: retries that fit the rate limit

Three workflow tools calling one API with sensible retries: n8n with Retry On Fail and batching, Azure Logic Apps with a retry policy and a loop set to one iteration at a time, Power Automate with an exponential retry policy; the card shows our n8n 2.45.7 run, which succeeded with 3 tries allowed and 5000 ms between tries.
Three workflow tools calling one API with sensible retries: n8n with Retry On Fail and batching, Azure Logic Apps with a retry policy and a loop set to one iteration at a time, Power Automate with an exponential retry policy; the card shows our n8n 2.45.7 run, which succeeded with 3 tries allowed and 5000 ms between tries.

In n8n, turn on Retry On Fail in the HTTP Request node's settings and add the Batching option to space requests out. In Azure Logic Apps and Power Automate, set the action's retry policy and pace the loop to one call at a time. In all three, a call that answers 429 should be followed by a pause, and a long job should be queued and polled.

We ran the n8n part on 20 November 2026 with n8n 2.45.7 against the QuanticData API. The Logic Apps and Power Automate sections quote Microsoft Learn, cited at the end.

What each tool does when a call fails

n8nAzure Logic AppsPower Automate
Where the setting isNode settings: Retry On FailHTTP action settings: Retry policyAction settings: Retry policy
DefaultOffOn: up to 4 retries at growing intervalsSee the action's settings
Which answers are retriedAny failed execution of the node408, 429 and 5xxTransient failures
Limits of the settingAt most 5 tries, up to 5000 ms apartUp to 90 attempts on Consumption workflowsInitial interval and maximum count
Spacing requests in a loopBatching option, or Loop Over Items with WaitFor each concurrency (default 20 at once) and a DelaySee the section below

Logic Apps and Power Automate columns: Microsoft Learn, see sources.

The pattern behind the table: a retry policy is for a transient failure, a timeout or a 502, 503 or 504 that will pass. A rate limit is different. There the fix is to send fewer requests per minute, and retries only help if they wait long enough.

n8n: the HTTP Request node, as we ran it

Our workflow has three nodes: a Manual Trigger, an Edit Fields node that sets url, and an HTTP Request node that sends the URL to the web scraping API. The request:

FieldValue
MethodPOST
URLhttps://api.quanticdata.io/v1/scraper/extract
Send HeadersAuthorization = Bearer followed by your API key
Send Body (JSON){{ JSON.stringify({ url: $json.url, format: 'markdown' }) }}
Options, Timeout90000
Options, BatchingItems per Batch 1, Batch Interval 3000
Settings, Retry On FailOn, Max Tries 3, Wait Between Tries 5000

In the workflow JSON, the retry settings sit on the node and the batching inside its options:

{
  "name": "QuanticData scrape",
  "type": "n8n-nodes-base.httpRequest",
  "typeVersion": 4.2,
  "parameters": {
    "method": "POST",
    "url": "https://api.quanticdata.io/v1/scraper/extract",
    "sendHeaders": true,
    "headerParameters": { "parameters": [ { "name": "Authorization", "value": "=Bearer {{ $env.QD_API_KEY }}" } ] },
    "sendBody": true,
    "specifyBody": "json",
    "jsonBody": "={{ JSON.stringify({ url: $json.url, format: 'markdown' }) }}",
    "options": { "batching": { "batch": { "batchSize": 1, "batchInterval": 3000 } }, "timeout": 90000 }
  },
  "retryOnFail": true,
  "maxTries": 3,
  "waitBetweenTries": 5000
}

Executed from the command line, the run ended like this, with the page title and its Markdown in the node's output:

$ n8n execute --id=WORKFLOW_ID
  ...
  "lastNodeExecuted": "QuanticData scrape"
  ...
  "startedAt": "2026-11-20T18:33:17.393Z",
  "stoppedAt": "2026-11-20T18:33:24.513Z",
  "status": "success",
  "finished": true

We kept the key in an environment variable of the n8n container and read it with $env; a Header Auth credential does the same job inside n8n's own credential store. Three things to know, from the n8n documentation:

  • Retry On Fail has ceilings: five tries at most and 5000 ms between them at most.
  • It does not read Retry-After. The node waits the time you set, not the time the API asks for.
  • Batching is the pacing tool. Each input item becomes one request; Items per Batch 1 with a Batch Interval of 3000 ms sends 20 requests a minute. For longer pauses, use Loop Over Items with a Wait node.

So for a pay-as-you-go API key, which allows 20 requests a minute, the settings above keep a list of any length inside the limit, and the three tries cover a transient error. Routing n8n traffic through a proxy is a different setting, covered in how to use a proxy in n8n.

Azure Logic Apps: retry policy and loop concurrency

Microsoft Learn (Handle errors and exceptions in Azure Logic Apps) describes the HTTP action's behaviour this way: when a request times out or fails with a 408, 429 or 5xx response, the retry policy resends it. Unless you choose otherwise, the Default policy applies: an exponential interval policy that sends up to 4 retries, at intervals that scale by 7.5 seconds and are capped between 5 and 45 seconds.

That default is sensible for one call. In a loop it multiplies. A For each loop runs up to 20 iterations at the same time by default (Microsoft Learn, limits and configuration reference), so a list of domains or URLs arrives at the API as bursts of 20, and each call that is turned away comes back up to four more times. Two settings bring it in line:

  • For each, Settings, Concurrency control: turn it on and set the degree of parallelism to 1. Add a Delay action of 3 seconds inside the loop for a 20-per-minute key.
  • HTTP action, Settings, Retry policy: choose a fixed or exponential policy with a small count and a real interval. In code view it is a retryPolicy object in the action's inputs:
"inputs": {
  "method": "POST",
  "uri": "https://api.quanticdata.io/v1/scraper/extract",
  "headers": { "Authorization": "Bearer @{parameters('QD_API_KEY')}", "Content-Type": "application/json" },
  "body": { "url": "@{items('For_each')}", "format": "markdown" },
  "retryPolicy": { "type": "exponential", "count": 3, "interval": "PT20S", "minimumInterval": "PT10S", "maximumInterval": "PT1M" }
}

The field names and the ISO 8601 durations are the documented ones: type is default, none, fixed or exponential, count goes from 1 to 90, and intervals on Consumption workflows go from 5 seconds to 1 day, per Microsoft Learn's retry policy reference. Check every expression against your own workflow before saving.

Power Automate: the retry policy in the action settings

Microsoft Learn's Power Automate guidance (Employ robust error handling) is to configure the retry policy in the settings of the action, choosing fixed or exponential intervals, an initial interval and a maximum retry count, and it recommends exponential policies because they lengthen the wait as retries go on. For an HTTP action that calls an API with a per-minute limit:

  • Open the action's settings and set an exponential policy with a small count and an initial interval of several seconds.
  • Our own advice, not a Microsoft statement: if the flow loops over a list, pace it the way the Logic Apps section describes, one item at a time, with a pause sized to the limit, which is 3 seconds for 20 requests a minute.
  • Watch the first runs in the flow's run history and adjust the settings, as the guidance suggests.

Long calls: queue, then poll

A workflow action does not wait for ever. Microsoft Learn's limits and configuration reference gives 120 seconds for an outbound request on Consumption logic apps and recommends an asynchronous polling pattern or an Until loop for longer operations. APIs built for automation support exactly that. On the QuanticData API a collector run or a batch answers at once with a job and a URL to poll:

POST /v1/scraper/collectors/whois_domain/run      202
{"type":"response","message":"Collector run queued",
 "payload":{"run_id":"RUN_ID","status":"queued","statusUrl":"/api/v1/scraper/collectors/runs/RUN_ID"}}

GET  /v1/scraper/collectors/runs/RUN_ID           200
{"type":"response","message":"Collector run","payload":{"status":"done","count":23, ...}}

That exchange is from our bulk WHOIS lookup test: 23 domains in one call, done about 2 seconds later. In a workflow it becomes three steps:

  • Submit with one HTTP action and keep run_id.
  • Wait and poll in an Until loop (Logic Apps, Power Automate) or a Wait node followed by an If (n8n), until status is done.
  • Read the rows from the last poll.

One submitted job replaces many single calls, which is also the simplest way to stay under a per-minute limit: 25 domains are one run, and up to 5,000 URLs are one batch.

A checklist before you switch the workflow on

  • Run it once with one item and read the response body, not only the status.
  • Count requests per minute at full speed: iterations at once, times retries. Compare with your key's limit, which the API returns in X-RateLimit-Limit and X-RateLimit-Remaining on every response.
  • Retry only 429, with the wait in Retry-After, and 502, 503 or 504. A 400, 401 or 402 will not change on a second try: fix the input, the key or the balance instead.
  • How to read that wait is in Retry-After header.
  • Give the workflow a stop condition, so a persistent error ends the run and reaches you as an alert.

Endpoints, limits per tier and the error table are in the API reference. If you build in Zapier, the same three ideas apply: one job instead of many calls, a delay in loops, and a poll for long work.

Sources & further reading

FAQ

Quick answers on n8n HTTP Request retry.

Something else? Ask us

How do I retry a failed HTTP Request in n8n?

Open the node's Settings tab, turn on Retry On Fail and set Max Tries and Wait Between Tries. The n8n documentation gives the ceilings: five tries and 5000 ms. Our run on n8n 2.45.7 used 3 tries and 5000 ms.

Does n8n respect the Retry-After header?

According to the n8n documentation, the HTTP Request node does not honour Retry-After automatically. Pace requests with the Batching option, or with Loop Over Items and a Wait node.

What is the default retry policy in Azure Logic Apps?

Per Microsoft Learn, an exponential interval policy that sends up to 4 retries at intervals that scale by 7.5 seconds, capped between 5 and 45 seconds. It applies to 408, 429 and 5xx responses and to timeouts.

How do I stop a Logic Apps loop from sending requests in parallel?

In the For each loop's settings, turn on Concurrency control and set the degree of parallelism to 1. The documented default is 20 iterations at the same time.

How many requests per minute should a workflow send?

Fewer than your API key allows. For the QuanticData pay-as-you-go tier that is 20 a minute: one request every 3 seconds, or better, one batch or collector run that carries the whole list.

What if an API call takes longer than the workflow action waits?

Use the asynchronous pattern: submit the job, keep its id, and poll its status in an Until loop or with a Wait node. The Microsoft Learn limits and configuration reference gives 120 seconds for an outbound request on Consumption logic apps.

An API that fits a workflow

Jobs that queue and report back, limits in every response header, and one call for a whole list.

Related reading