Overcoming the 2,000-Record Collection Limit in Power Apps: Four Proven Methods

Power Apps caps the number of records retrieved from most data sources at 2,000 due to the delegation boundary. This limit can be a roadblock when you need to populate a local collection with thousands of rows for offline use or to accelerate lookups. However, with a few clever patterns you can store far more than 2,000 records in a single collection.

In this article, we’ll explore four techniques that let you build collections larger than the default limit. We'll use a Customer Orders SharePoint list as our main data source—it has the following columns:

• OrderID (number, primary key)
• CustomerName (text)
• Product (text)
• Quantity (number)
• OrderDate (date)

The list contains 5,000 orders, enough to demonstrate each approach.

1. Concurrent Chunking & Deduplication

The delegation limit applies only when reading from an external data source, not when merging local data. You can use the Concurrent function to load two sorted chunks—one ascending, one descending—and then combine them into a single collection. Because each chunk can pull up to 2,000 rows, the merged result can hold up to 4,000 records.

Place this code in a button’s OnSelect property:

Concurrent(
    ClearCollect(colOrdersAsc, Sort('Customer Orders', "OrderID", SortOrder.Ascending)),
    ClearCollect(colOrdersDesc, Sort('Customer Orders', "OrderID", SortOrder.Descending))
);
ClearCollect(
    colOrders,
    colOrdersAsc,
    Filter(colOrdersDesc, Not(OrderID in colOrdersAsc.OrderID))
);
Clear(colOrdersAsc);
Clear(colOrdersDesc);

After running the button, you can verify the row count:

"Total orders: " & CountRows(colOrders)

Limitation: This method doubles the limit to 4,000 rows. If your data set is larger, you would need more chunks—but the complexity grows quickly.

2. ForAll Over a Set of Filter Values

The ForAll function can be used to execute multiple Collect calls, each pulling up to 2,000 rows for a specific filter value. As long as the individual filter results stay under the delegation limit, the combined collection can hold thousands of records.

Suppose you want to collect all orders for the top‑selling products: "Widget A", "Widget B", and "Widget C". Use this code:

Clear(colOrders);
ForAll(
    ["Widget A", "Widget B", "Widget C"],
    Collect(colOrders, Filter('Customer Orders', Product = Value))
);

Each product’s result set must be ≤ 2,000 rows, but the total collection can go beyond that limit.

This technique is especially useful when you let users select multiple values from a combo box. For example, if a ComboBox allows selecting several customer names, you can collect all matching orders:

Clear(colOrders);
ForAll(
    ComboBox1.SelectedItems.Value,
    Collect(colOrders, Filter('Customer Orders', CustomerName = Value))
);

3. Power Automate HTTP Response (Premium)

If you have access to premium connectors (Power Apps per app or per user plan), you can use a Power Automate flow to fetch all records and return them to Power Apps via a Response action. The flow bypasses the 2,000 delegation limit because the data travels as a JSON payload.

Here’s a high‑level walkthrough using Dataverse:

1. Create a new flow with the Power Apps button trigger.
2. Add a List rows action for your Dataverse table (e.g., Customer Orders). Remove any row count limit to retrieve all rows.
3. Add a Response action. Set the body to the value property from the list rows action. To generate the schema, use a sample JSON array (copy a few records from the output).
4. Save the flow and connect it in Power Apps via the Action tab.

Then you simply call the flow from a button:

ClearCollect(colOrders, LoadAllOrders.Run());

Label to confirm the row count:

"Total orders: " & CountRows(colOrders)

Because the flow runs with its own service account, it can pull as many rows as the source allows (within the 256 MB HTTP response limit). This gives you a collection with the full data set.

4. Static Data from Excel (Import from Excel Connector)

For data that rarely changes—like a product catalog, postal code list, or dictionary—you can use the Import from Excel connector. Power Apps loads the Excel file directly into the app, bypassing delegation entirely. Each Excel table you connect can contain up to 15,000 rows. By splitting your data into multiple tables (each ≤ 15,000 rows) and combining them, you can create collections of 100,000 records or more.

Example: a product reference table with 45,000 entries.

1. Split the data into three Excel tables: ProductRef1, ProductRef2, ProductRef3.
2. Add the Import from Excel data source to your app and select all three tables.
3. Use a button to combine them:

ClearCollect(colProducts, ProductRef1, ProductRef2, ProductRef3);

Check the count:

"Total products: " & CountRows(colProducts)

All 45,000 rows are now available locally.

When to use: This method is ideal for reference data that does not change frequently. If the source Excel file is updated, you must re‑import the data source from the app’s settings—there is no live connection.

Common Pitfalls & Troubleshooting

• Overlapping chunks in the concurrent method: If your key column is not sequential or has gaps, the ascending and descending chunks may overlap more heavily, reducing the final row count. Using a different column like a timestamp can help, but the duplication will still be limited.
• ForAll with too many values: If you iterate over a large list of values, each Collect call runs sequentially and can degrade app performance. Use Concurrent around the ForAll only if you’re sure about race conditions.
• Power Automate response size: The HTTP Response action has a 256 MB payload limit. Monitor the size of your JSON payload and consider paging if necessary.
• Excel row limit: Each Excel table imported via the connector is capped at 15,000 rows. Plan your splits carefully.
• Delegation warnings: Even with these workarounds, any Filter or LookUp that queries the original data source after the collection is built will still respect the original 2,000 limit. Move as much data into the collection upfront as your scenario requires.

Final Recommendation

The right technique depends on your data size, update frequency, and licensing:

Start with the simplest option that meets your needs. For most apps that need just a few thousand extra records, the concurrent chunking method is a quick fix. When you require tens of thousands of rows and have the budget, Power Automate is the most flexible.

References

• Original article by Matthew Devaney: Create Power Apps Collections Over 2000 Rows With These 4 Tricks
• Microsoft docs: Understand delegation in a canvas app
• Microsoft docs: Power Apps – Import from Excel