# n8n HTTP Request Retry and Logic Apps Policy

> Set retries for API calls in n8n, Azure Logic Apps and Power Automate: Retry On Fail, batching, retry policy, loop concurrency and the async pattern.

[Home](https://quanticdata.io/) / [Blog](https://quanticdata.io/blog/) / n8n HTTP Request Retry and Logic Apps Policy

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

Guides · Nov 20, 2026 · 7 min read · By [Aldo Morese](https://quanticdata.io/about/), founder of QuanticData

![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.](https://quanticdata.io/blog/api-retry-n8n-logic-apps-power-automate/hero.webp?v=20261120h)

On this page

- [What each tool does when a call fails](https://quanticdata.io/blog/api-retry-n8n-logic-apps-power-automate/#what-each-tool-does-when-a-call-fails)
- [n8n: the HTTP Request node, as we ran it](https://quanticdata.io/blog/api-retry-n8n-logic-apps-power-automate/#n8n-the-http-request-node-as-we-ran-it)
- [Azure Logic Apps: retry policy and loop concurrency](https://quanticdata.io/blog/api-retry-n8n-logic-apps-power-automate/#azure-logic-apps-retry-policy-and-loop-concurrency)
- [Power Automate: the retry policy in the action settings](https://quanticdata.io/blog/api-retry-n8n-logic-apps-power-automate/#power-automate-the-retry-policy-in-the-action-settings)
- [Long calls: queue, then poll](https://quanticdata.io/blog/api-retry-n8n-logic-apps-power-automate/#long-calls-queue-then-poll)
- [A checklist before you switch the workflow on](https://quanticdata.io/blog/api-retry-n8n-logic-apps-power-automate/#a-checklist-before-you-switch-the-workflow-on)

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.

**Run it on the free credit.** Every QuanticData account gets $2 of free API usage per month.

[Start free — $2/month included](https://quanticdata.io/signup/?utm_source=blog&utm_medium=website&utm_campaign=blog-lead&utm_content=api-retry-n8n-logic-apps-power-automate) · [Explore AI Web Scraping Service](https://quanticdata.io/ai-web-scraping-service/)

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

|  | n8n | Azure Logic Apps | Power Automate |
| --- | --- | --- | --- |
| Where the setting is | Node settings: Retry On Fail | HTTP action settings: Retry policy | Action settings: Retry policy |
| Default | Off | On: up to 4 retries at growing intervals | See the action's settings |
| Which answers are retried | Any failed execution of the node | 408, 429 and 5xx | Transient failures |
| Limits of the setting | At most 5 tries, up to 5000 ms apart | Up to 90 attempts on Consumption workflows | Initial interval and maximum count |
| Spacing requests in a loop | Batching option, or Loop Over Items with Wait | For each concurrency (default 20 at once) and a Delay | See 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](https://quanticdata.io/web-scraping-api/). The request:

| Field | Value |
| --- | --- |
| Method | POST |
| URL | `https://api.quanticdata.io/v1/scraper/extract` |
| Send Headers | `Authorization` = `Bearer` followed by your API key |
| Send Body (JSON) | `{{ JSON.stringify({ url: $json.url, format: 'markdown' }) }}` |
| Options, Timeout | 90000 |
| Options, Batching | Items per Batch 1, Batch Interval 3000 |
| Settings, Retry On Fail | On, Max Tries 3, Wait Between Tries 5000 |

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

```json
{
  "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:

```bash
$ 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](https://quanticdata.io/blog/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.

**Try it on your own targets.** Every QuanticData account gets $2 of free API usage per month.

[Start free — $2/month included](https://quanticdata.io/signup/?utm_source=blog&utm_medium=website&utm_campaign=blog-inline&utm_content=api-retry-n8n-logic-apps-power-automate) · [Explore AI Web Scraping Service](https://quanticdata.io/ai-web-scraping-service/)

## 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](https://quanticdata.io/blog/bulk-whois-lookup-rdap/) 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](https://quanticdata.io/blog/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](https://quanticdata.io/docs/). If you build in [Zapier](https://quanticdata.io/integrations/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

- [n8n Docs: Handle rate limits](https://docs.n8n.io/integrations/builtin/rate-limits/)
- [Microsoft Learn: Handle errors and exceptions in Azure Logic Apps (retry policies)](https://learn.microsoft.com/en-us/azure/logic-apps/logic-apps-exception-handling)
- [Microsoft Learn: Limits and configuration reference for Azure Logic Apps](https://learn.microsoft.com/en-us/azure/logic-apps/logic-apps-limits-and-config)
- [Microsoft Learn: Power Automate, employ robust error handling](https://learn.microsoft.com/en-us/power-automate/guidance/coding-guidelines/error-handling)
- [RFC 9110: Retry-After](https://www.rfc-editor.org/rfc/rfc9110#field.retry-after)

## FAQ

Quick answers on n8n HTTP Request retry.

[Something else? Ask us](mailto:hello@quanticdata.io)

### 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.

[Start free — $2/month included](https://quanticdata.io/signup/?utm_source=blog&utm_medium=website&utm_campaign=blog-end&utm_content=api-retry-n8n-logic-apps-power-automate) · [Explore AI Web Scraping Service](https://quanticdata.io/ai-web-scraping-service/)

## Related reading

- [How to Use a Proxy in n8n](https://quanticdata.io/blog/how-to-use-a-proxy-in-n8n/): Guides · Two ways to route n8n through a proxy — per-node in the HTTP Request node or globally with env vars — the gotchas that trip people up, and rotation for scraping.
- [Direct Image URL: What It Is, How to Check](https://quanticdata.io/blog/direct-image-url/): SERP & search · A direct image URL answers with the image file: its Content-Type starts with image/. A page that displays the picture answers with text/html. Below: how to tell them apart in one curl command, how to get the direct link from a page or a photo host, and what our reverse image search API did with each kind of URL in tests on 20 November 2026.
- [How to Use an API Key: curl, Python and JS](https://quanticdata.io/blog/how-to-use-an-api-key/): Web scraping · An API key is a secret string you send with every request so the service knows which account is calling. Nothing is installed: you add one header. Below: the same call in curl, Python, JavaScript and PowerShell, run on 20 November 2026 against the QuanticData API, the exact 401 messages for the usual mistakes, and how to keep the key out of your code.

---

Source: https://quanticdata.io/blog/api-retry-n8n-logic-apps-power-automate/ · Site index for AI: https://quanticdata.io/llms.txt
