Collab365

Power Automate and API timeout errors

Q: Why does Postman work but Power Automate fails?

Postman is a desktop testing tool without strict global timeouts. Power Automate is a shared cloud service that terminates synchronous connections after 120 seconds to preserve server health.

C

Collab365 TeamAuthorPublished Apr 22, 2026

4

At a Glance

Target Audience: Power Automate Developers, Citizen Developers
Problem Solved: Power Automate flows failing with 120-second HTTP timeout errors when fetching large historical datasets from APIs.
Use Case: Automating pulls of historical API data (e.g., currency rates) into SharePoint, Excel or reports without flow failures.

Power Automate HTTP actions timeout at 120 seconds in 2026 per official Microsoft limits.1 If you are trying to download massive historical datasets, this strict two-minute cut-off will cause your flow to fail.

You can fix it with built-in pagination, split calls by date ranges, or switch to Azure Logic Apps (which offer higher timeouts like 4 minutes). Here is exactly how we solve this problem without needing a computer science degree.

We saw this exact problem pop up on the Collab365 forums recently. A user named AndrewS was trying to pull historical currency rates, and his flows kept dying at the two-minute mark. Meanwhile, the exact same request succeeded in Postman after just 40 seconds.

Why the difference? Power Automate enforces a hard limit on synchronous HTTP requests to keep the platform stable.1 You cannot increase this 120-second threshold under any circumstances.

However, you can easily bypass it by changing how you ask for the data.

Key Takeaway: Power Automate enforces a non-negotiable 120-second timeout on all standard synchronous HTTP requests, regardless of your licence tier.1

TL;DR Box: 5 Fixes Ranked by Ease

Built-in Pagination (Easiest): Toggle a switch in the HTTP action settings.
- Pros: No code, takes 10 seconds to set up.
- Cons: Fails if your API does not return a standard 'next link'.
Split Calls by Date Range (Most Reliable): Use a 'Do until' loop to ask for one month of data at a time.
- Pros: Works on almost any historical data API.
- Cons: Requires initialising a few variables and expressions.
Custom Connector Async Pattern (Cleanest): Use the 202 Accepted status code for polling.
- Pros: Microsoft handles the waiting in the background.
- Cons: The external API must explicitly support asynchronous polling.
Logic Apps Migration (Best for Enterprise): Move the flow to Azure.
- Pros: Standard Logic Apps give you up to 240 seconds for outbound calls.
- Cons: Involves Azure billing rather than a flat Microsoft 365 licence.
Azure Functions (Most Powerful): Write custom scripts.
- Pros: Flex Consumption plans offer practically unbounded maximum timeouts.
- Cons: Requires pro-developer coding skills in languages like C# or Python.

Who Gets Power Automate API Timeouts — and Why?

If you are a beginner, timeout errors can feel completely random. You might build a flow that works perfectly in testing. Then, three weeks later, it fails on a Monday morning when the server is busy.

This happens because of the difference between synchronous and asynchronous operations. A synchronous HTTP call expects an immediate answer. Power Automate opens a connection to the external server and waits patiently on the line.1

If that external server takes 121 seconds to gather the data, Power Automate aggressively closes the connection. It returns a 504 Gateway Timeout or a TaskTimedOut error.

Key Takeaway: Synchronous HTTP calls force Power Automate to hold an open connection, which is why strict time limits are enforced to protect server capacity.1

AndrewS experienced this when pulling exchange rates from an API for a large five-year window. We tested this scenario with popular currency APIs like Fixer.io and ExchangeRate-API.2 When you ask these services for five years of daily data, their databases have to crunch thousands of numbers.

Postman works fine because it is an API testing tool installed on your local machine, not a managed cloud service. It has no strict global timeout unless you configure one manually. It will happily sit and wait for 60 seconds, or even 5 minutes, until the server replies.

Power Automate, running on shared Microsoft infrastructure, cannot afford to leave open connections hanging forever. The system limits are rigid to prevent badly designed flows from hogging backend resources.4

When we review beginner flows at Collab365, this is a top-three mistake. Users assume API performance is a constant. In reality, as your database grows, your API calls take longer to process.

Key Takeaway: Do not trust a single successful test run in Postman; you must design your flows assuming the API will eventually slow down under heavy load.

Eventually, those calls creep past the 120-second mark. Your previously stable flow suddenly breaks daily. To fix this, we must change how we ask the server for data. We cannot ask for the entire pie at once; we must ask for individual slices.

Furthermore, you must also consider Power Platform Request (PPR) limits.6 Every time your flow runs an action, it counts against your daily quota.4 A simple flow with one trigger and one action consumes two requests every time it fires.4

If you build a poor loop to fix your timeout, you might accidentally hit your daily action limit instead. We must be strategic about how we fetch this data.

What Are the 2026 Power Automate HTTP Timeout Limits?

Before we look at the solutions, we need to completely understand the technical boundaries. Microsoft updates these limits occasionally, but the core HTTP timeout has remained stubbornly fixed.

According to the 2026 Microsoft Learn documentation, an outbound synchronous request in Power Automate is limited to exactly 120 seconds.1 Inbound requests (like when a web-hook triggers your flow) also have a 120-second limit.1

Key Takeaway: You absolutely cannot ring Microsoft support to request a timeout extension for standard Power Automate HTTP actions.1

If you are using Azure Logic Apps, the rules are slightly different. Logic Apps come in two flavours: Consumption (multitenant) and Standard (single-tenant).5

In a Logic Apps Consumption plan, your HTTP timeouts are also generally limited to 120 seconds for standard inbound and outbound calls.5 You share this environment with thousands of other organisations, so the restrictions mirror Power Automate.

However, Standard Logic Apps provide more breathing room. Outbound HTTP calls in single-tenant Standard environments can reach 240 seconds (4 minutes).5 This is because you are paying for dedicated compute power.

If you step into pro-developer territory with Azure Functions, the limits disappear entirely. The new Flex Consumption plan has a default timeout of 30 minutes, but the maximum is essentially unbounded.8 Older legacy Consumption plans for Azure Functions enforce a 5-minute default and a 10-minute maximum.8

Here is a breakdown of the 2026 limits across the Microsoft ecosystem.

Service & Tier	Execution Timeout Limit	Best Used For
Power Automate (All licences)	120 seconds	Citizen developers, everyday office tasks
Logic Apps (Consumption)	120 seconds	Cheap, infrequent enterprise integrations
Logic Apps (Standard)	240 seconds (outbound)	Complex, mission-critical business processes
Azure Functions (Flex Consumption)	30 minutes (unbounded max)	Heavy data processing and pro-code logic
Azure Functions (Legacy Consumption)	10 minutes maximum	Older serverless compute workloads

Data sourced from official Microsoft Learn documentation.1

As you can see, Power Automate is the most restrictive platform. But you do not need to upgrade to Azure immediately. We can apply simple software engineering principles to our citizen developer flows.

Key Takeaway: Azure platforms offer higher timeouts because you pay directly for the underlying compute resources, unlike flat-rate Microsoft 365 licences.9

In addition to timeouts, remember that 2026 brings new transitional limits for Power Platform Requests. If your flow relies on heavy looping, you must be aware of your daily action quotas.

For a standard Microsoft 365 user, the enforced limit during the transition period is 6,000 requests per user.10 If you have a Premium user licence, you get 40,000 requests per user plus a transition buffer of 200,000 per flow.10

If your timeout fix requires building a loop with 10,000 actions, you could easily breach a free tier limit. Efficiency is just as important as avoiding timeouts.

Fix #1: Use Built-in Pagination (Easiest for Beginners)

If you are dealing with large datasets, the API provider usually splits the data into "pages". Think of a standard Google search result. You do not get 5 million results on one single screen; you get 10 results and a button to view the next page.11

APIs work in exactly the same way. When you ask for historical currency data, the server might only return the first 1,000 records. It will also provide a special web address, called a "next link", which tells your system exactly how to fetch records 1,001 to 2,000.12

Key Takeaway: Pagination forces the API server to return small, fast chunks of data, preventing the 120-second timeout entirely.12

Power Automate has a brilliant, hidden feature to handle this automatically. You do not need to write complex manual loops to follow these links. You just need to flip a single switch in the action settings.14

We tested this with a generic list of 20,000 SharePoint items, and the built-in pagination succeeds 90% of the time.15 Here is how you configure it properly without making rookie mistakes.

Step-by-Step Pagination Setup

First, add your standard 'HTTP' action to your flow. Enter the API URL for your historical data. We usually start by testing the API in Postman to see exactly what the JSON response looks like.

Next, run a quick test in Power Automate without pagination. Look at the raw output body of your HTTP action. You are searching for a property that looks like a web link.

In Microsoft Graph APIs, this pagination link is usually called @odata.nextLink.16 In custom third-party APIs, it might just be called next_page or nextLink.18

Key Takeaway: You must run a test call first to find the exact name of the next link property in the JSON payload.16

Once you have identified the exact name of the next link field, click the three dots (...) in the top right corner of your HTTP action.14

Select Settings. This opens a new menu where the configuration magic happens.

Turn the Pagination toggle to the On position.14 Two new fields will appear on your screen: 'Threshold' and 'Next link'.

Setting the Threshold and Next Link

The Threshold is the maximum total number of records you want Power Automate to fetch across all combined pages.12 The absolute maximum configurable threshold here is 100,000.14

If your API returns 1,000 records per page, and you set a threshold of 5,000, Power Automate will rapidly make five separate API calls behind the scenes. Because each call only grabs 1,000 records, none of them will hit the two-minute timeout.12

The pagination threshold is not a hard stop. Power Automate actually rounds up to the nearest page increment to fulfill your request.12

Key Takeaway: If your threshold is 7,000 and the page size is 5,000, Power Automate will pull two full pages, returning 10,000 rows.14

This trips up many beginners. They expect exactly 7,000 rows and their subsequent Excel or SharePoint actions fail because they did not account for the extra 3,000 rows. Always handle the exact array size in your subsequent steps.

In the Next link field, you must tell Power Automate exactly where to find the URL for the next page.19 This is where beginners often make frustrating mistakes.

If your API response looks like this:

{ "data": [...], "nextLink": "https://api.com/page2" }

You must enter the exact path to that field. Usually, you simply type the property name into the box, but if it is nested, you may need a specific expression.

Why Built-in Pagination Fails

We have seen plenty of screenshots on the forums where this simple toggle fails completely. The most common reason is that the external API does not provide an absolute URL.

Sometimes, an API will only provide a partial, relative link, like ?page=2. Power Automate's built-in pagination cannot handle this formatting natively. It strictly requires a full, absolute web address starting with https://.13

Another common error involves HTTP headers. Sometimes, an API provides the pagination instructions inside the HTTP response headers rather than the JSON body.18

Key Takeaway: Power Automate's simple pagination toggle cannot read 'next links' hidden inside HTTP response headers.18

If your API does not play nicely with the standard toggle, do not panic. We just need to build the pagination loop manually. This leads us to the most robust and highly customisable fix.

Fix #2: Split Large Requests into Smaller Chunks

If the simple toggle fails, we must take full control of the request architecture. According to Collab365 splitting massive requests into smaller date chunks is the most reliable way to avoid timeouts.

This is essentially building a custom pagination system from scratch. Instead of asking the API for 10 years of currency data, we ask for one year at a time.

A 'Do until' loop allows you to make repeated, fast API calls, completely sidestepping the 120-second timeout risk.20 We will use this control to step through our date ranges systematically.

We will use a Do until loop for this.21 A Do-until loop repeats a set of actions endlessly until a specific condition evaluates to true.20 In our case, we will loop until our "current date" reaches our "target end date".

Do-until loops can be intimidating for beginners because they require expressions, but they are incredibly powerful.22 We use them constantly in Collab365, here is the ultimate guide to setting one up.

Step 1: Initialise Your Variables

Before the loop begins, we need to create some variables. Think of these as sticky notes on your desk where we write down our current progress.

Create an Initialise variable action. Name it varStartDate and set the type to String. Give it your starting date, for example, 2020-01-01.

Create a second variable named varEndDate. Set it to your final target date, like 2025-12-31.

Key Takeaway: Always declare your start and end dates as string variables outside the loop to keep your logic clean and easy to modify later.

Create a third variable named varCurrentDate. Set its initial value to exactly match your varStartDate. This is the sticky note we will actively update during the loop.

Finally, create a fourth variable named varAllResults. Set the type to Array, and leave the value completely blank. We will dump all our successful API responses into this master bucket as the loop runs.

Step 2: Configure the Do-Until Loop

Add a Do until control action.21 You will see a condition box. We want to tell the flow to keep running until our current date is greater than our end date.

In the left box of the condition, put your varCurrentDate variable. In the middle dropdown, select is greater than. In the right box, put your varEndDate variable.

Power Automate can be notoriously fussy about date comparisons. You must ensure both dates are in the exact same format, or the loop will fail instantly.

We highly recommend wrapping your variables in a formatDateTime expression to force a standard layout.23

For example, your left value expression should look exactly like this: formatDateTime(variables('varCurrentDate'), 'yyyy-MM-dd').23 The right side should be formatDateTime(variables('varEndDate'), 'yyyy-MM-dd').23

Key Takeaway: Always use the formatDateTime expression when comparing dates in a loop to prevent silent infinite looping errors.23

Step 3: Call the API Inside the Loop

Now, drag your HTTP action inside the Do-until loop. We need to modify the API URL so it only asks for a specific chunk of time rather than the entire historical range.

Let us assume we want to pull data exactly 30 days at a time. Your API URL probably has parameters for start_date and end_date in the query string.

Map the API's start_date parameter directly to your varCurrentDate variable.

For the API's end_date parameter, we need to calculate a date 30 days in the future. Use the addDays expression. It will look like this: addDays(variables('varCurrentDate'), 30, 'yyyy-MM-dd').

When the loop runs, the HTTP action will request exactly 30 days of data. This small request will complete in seconds, completely avoiding the 120-second timeout limit.

Step 4: Store the Data and Increment the Date

Directly below the HTTP action (but still inside the loop), add an Append to array variable action. Choose your varAllResults array.

For the value, select the Body output of your HTTP action. This saves the 30 days of data safely into our master bucket.17

Key Takeaway: Appending results to an array variable ensures you do not overwrite your data on each iteration of the loop.17

Finally, we must update our sticky note. If we do not change the varCurrentDate, the loop will run forever, requesting the same 30 days endlessly.

Add a Set variable action. Choose varCurrentDate. We want to move our current date forward by 30 days, ready for the next loop.21

Use the exact same expression: addDays(variables('varCurrentDate'), 30, 'yyyy-MM-dd').

When you test the flow, it will rapidly cycle through the months. Each loop makes a lightning-fast API call. At the end, your varAllResults array will contain the full massive dataset.

Changing Do-Until Limits

There is one hidden trap with Do-until loops that catches almost every beginner. Power Automate applies default safety limits to prevent runaway loops from destroying system resources.24

By default, a Do-until loop will silently stop after 60 iterations, or after 1 hour (PT1H) of processing, whichever comes first.24

If you are pulling 10 years of data in 30-day chunks, you will need about 120 loops. The flow will silently stop halfway through without throwing an error unless you change this default limit.

Key Takeaway: Always increase the default Count limit on a Do-until loop if you expect to process more than 60 chunks of data.24

Click the 'Change limits' option on your Do-until action.21 Increase the 'Count' to 5000 (the maximum allowed value).24 Change the Timeout string to PT72H (72 hours) to ensure it does not expire prematurely during a massive data pull.

Fix #3: Switch to Logic Apps or Azure Functions

Sometimes, citizen developer tricks are just not enough. If your API provider does not allow pagination, and the data cannot be logically split by date, you have hit a hard architectural wall.

At this point, you must move out of Power Automate entirely. The Collab365 team recommends starting with Azure Logic Apps for enterprise integrations.25

Logic Apps share the exact same visual designer canvas as Power Automate.26 The interface looks nearly identical, so beginners feel right at home.27 You do not need to learn a new coding language to make the jump.

However, Logic Apps run on a completely different billing and infrastructure model. You pay per execution rather than via a flat Microsoft 365 per-user licence.9

Key Takeaway: Logic Apps offer the same low-code experience as Power Automate but operate on a consumption-based billing model in Azure.9

Logic Apps Consumption vs Standard

If you use the basic Logic Apps Consumption tier, you are unfortunately still restricted to the same 120-second timeout.5 You share infrastructure with other companies in a multitenant setup, so Microsoft keeps the leashes extremely tight.7

To beat the timeout, you need the Logic Apps Standard tier.9 Standard runs on dedicated compute resources.9 Because you are paying a fixed monthly cost for the server space, Microsoft relaxes the rules considerably.

In a single-tenant Standard environment, your outbound HTTP calls can run for up to 240 seconds.5 This doubles your time limit instantly without requiring you to change a single piece of looping logic. Furthermore, stateful workflows in Standard Logic Apps can remain active for up to 90 days, allowing for massive, long-running processes.5

Key Takeaway: Logic Apps Standard instantly doubles your outbound API timeout limit to four minutes, making it ideal for heavy enterprise queries.5

The Ultimate Power: Azure Functions

If a four-minute timeout is still not enough for your historical API, you must graduate to Azure Functions.27 Azure Functions are serverless compute instances where you write actual backend code (usually C#, Python, or JavaScript).28

This is no longer a no-code solution. It requires a developer mindset. But it offers supreme flexibility and control.29

Historically, the Consumption plan for Azure Functions had a strict 5-minute timeout (configurable up to 10 minutes).8 However, as of 2026, Microsoft strongly pushes developers toward the Flex Consumption plan.8

The Flex Consumption plan gives you an practically unbounded maximum execution time.8 You can write a Python script to hit an incredibly slow API, let it run for 45 minutes, and then pass the final data safely back to your Power Automate flow.

You can easily orchestrate this hybrid approach. Power Automate handles the daily schedule and email notifications, calls the Azure Function to do the heavy lifting, and waits patiently for the result.26

Key Takeaway: For integrations that take longer than four minutes, a hybrid approach combining Power Automate orchestration with Azure Functions computation is the industry standard.25

Fix #4: Custom Connectors and Async Patterns

There is one more highly technical fix that requires zero code on your end, provided the external API is modern and well-designed. It is called the Asynchronous Polling Pattern.31

When Power Automate makes a standard synchronous HTTP call, it waits nervously for a 200 OK status code. This means "Here is your data, right now".

However, smart API architectures understand that huge datasets take time to generate. Instead of making your flow wait and risk a timeout, they immediately return a 202 Accepted status code.31

A 202 Accepted response means "I have received your request, and I am working on it. Check back later".31

Crucially, this response includes a special Location HTTP header containing a unique URL.31

Key Takeaway: The asynchronous pattern allows Power Automate to gracefully wait for data for hours without triggering the standard 120-second timeout error.31

If you turn on the Asynchronous Response setting in your HTTP action, Power Automate handles this entire dance automatically.32

It sees the 202 code. It closes the initial connection (avoiding the timeout). Then, in the background, it periodically pings that special Location URL to check if the data is ready.34

When the API finally finishes building the dataset (even if it takes 15 minutes), the polling URL returns a 200 OK with the data.34 Power Automate resumes your flow seamlessly as if nothing happened.

We absolutely love this pattern. Sadly, you cannot force it to happen. The external API must be explicitly built to support 202 Accepted responses.35 If you are querying a basic legacy API, this will not work.

If you are building your own Custom Connector to talk to an internal company database, ensure your developers implement this pattern.35 It saves endless headaches for citizen developers down the line.

Prerequisites and Common Mistakes to Avoid

Before you dive into complex loops or Azure migrations, check your basics. We see brilliant automations fail daily due to simple administrative errors or poor testing practices.

1. Test in Postman First

Never build a complex HTTP action in Power Automate blindly. Always test your API keys and URL structures in a dedicated tool like Postman first.

Verify that the API actually returns data. Check exactly how long the request takes to complete. If Postman shows a response time of 130 seconds, you immediately know you have a timeout issue. If Postman shows 10 seconds, your Power Automate failure is likely a simple authentication or syntax error, not a timeout limit.

Key Takeaway: Postman separates logic errors from timeout errors, saving you hours of frustrating debugging in the flow designer.

2. Secure Your API Keys

When building HTTP requests, do not paste your raw API keys directly into the URL or header fields. If you export the flow, those keys are visible to anyone.

Use environment variables to store your API keys securely. Even better, use Azure Key Vault if your organisation supports it. This ensures your sensitive historical data access remains strictly governed.

3. Check the 2026 HTTP Trigger URL Update

If you are using inbound HTTP triggers (where an external system sends data into your flow), be highly aware of the massive 2026 infrastructure change.36

Historically, Power Automate HTTP trigger URLs lived on the logic.azure.com domain.36 Microsoft is currently migrating these to the new api.powerplatform.com domain.36

Key Takeaway: Old logic.azure.com HTTP trigger URLs are being deprecated and will cause your inbound flows to fail if not updated.36

If you have old integrations hardcoded with the legacy URL, they will break. Microsoft extended the deadline to January 2026, but the cut-off is firm.37 You must open your flow, copy the newly generated api.powerplatform.com link, and update your external systems.36

4. Handle Empty Results Gracefully

When using the Do-until date looping method, you must account for empty periods. If you ask a currency API for weekend data, it might return an empty array because financial markets are closed.

If your flow blindly attempts to parse an empty array, it will crash. Always add a simple Condition action inside your loop to check if the data array is empty before appending it to your master variable.

Use the expression empty(body('HTTP')) to check if the response contains data. If true, skip the append action. If false, append the data safely.

FAQ

Can I increase the Power Automate timeout beyond 2 minutes? No. The 120-second limit for standard synchronous outbound requests is a hard platform limit set by Microsoft.1 It cannot be extended via support tickets or premium user licences.

How do I set up pagination for my API? Go to the settings of your HTTP action and toggle 'Pagination' to On.14 Set a threshold up to 100,000.15 You must also provide the exact path to the 'Next link' URL found in your API's JSON response.12

Why does Postman work but Power Automate fails? Postman is a desktop testing tool that does not enforce strict global timeouts. Power Automate is a shared cloud service that violently terminates any synchronous connection that lingers past 120 seconds to preserve server health.1

What is the difference between Logic Apps and Power Automate? They use the exact same visual designer, but Logic Apps is billed per-execution and built for enterprise integration.27 Crucially, Standard single-tenant Logic Apps allow for double the timeout duration (240 seconds) on outbound calls.5

How do I use a Do-Until loop for dates? Create variables for a start date, end date, and current date. Loop until the current date is greater than the end date.20 Inside the loop, make your API call, save the data, and use the addDays expression to step your current date forward.21

Close

API timeouts are undeniably frustrating, but they force us to build better, more resilient automations. Asking a server for massive blocks of data all at once is an outdated practice. By implementing intelligent pagination or systematic date-chunking, you create flows that are faster, lighter, and virtually immune to random timeout crashes.

Collab365 highly recommends starting with the simple 'Do-until' date chunking method for your historical API calls today. It requires no premium Azure services, works on almost any API, and teaches you incredibly valuable array manipulation skills.

For more research and updates, check the Power Automate Space on Collab365 Spaces — it has user flows like AndrewS's fully fixed and ready to go.38