Reducing API Calls for Better Performance in Power Apps

Efficiently managing API calls in Power Apps is crucial for improving app performance, reducing latency, lowering costs, and preventing throttling issues. Excessive API requests can slow down an app, overwhelm the backend, and lead to delegation limits, poor user experience, and unnecessary data refreshes.

This guide provides detailed and step-by-step strategies to reduce API calls while optimizing performance in Power Apps.

1. Understanding API Calls in Power Apps

1.1 What are API Calls in Power Apps?

API calls occur when Power Apps requests data from an external source like:
✅ Dataverse, SharePoint, SQL Server, or OneDrive
✅ REST APIs (custom or third-party services like Stripe, Salesforce, or Twilio)
✅ Microsoft Graph API for Office 365 Integration

1.2 Why Reduce API Calls?

🔹 Improves Performance → Reduces load time and response delays.
🔹 Avoids Throttling → Prevents hitting API request limits.
🔹 Reduces Costs → Some API providers charge per request.
🔹 Optimizes Network Usage → Avoids unnecessary data transfers.

2. Strategies to Reduce API Calls in Power Apps

2.1 Use Collections to Store Data Locally

Instead of calling an API multiple times, store data in a collection and reuse it.

Step 1: Load Data Once and Store in a Collection

ClearCollect(MyDataCollection, APIDataSource)

This retrieves data once and stores it in MyDataCollection.

Step 2: Use the Collection Instead of API Calls

Instead of fetching data from the API every time, reference MyDataCollection:

LookUp(MyDataCollection, ID = 101)

✅ Improves performance by reducing direct API calls.

2.2 Avoid Repeated API Calls with Variables

Scenario: If an API call is needed multiple times in a session, store the result in a global variable.

Step 1: Store API Response in a Variable

Set(UserInfo, Office365Users.MyProfile())

Fetches user info only once and stores it in UserInfo.

Step 2: Use the Variable Instead of Recalling the API

UserInfo.DisplayName

✅ Reduces unnecessary API calls for the same data.

2.3 Use the Delegation Feature to Minimize Data Transfer

Instead of fetching all records at once, delegate filtering to the data source.

❌ Bad Practice (Non-Delegable, Brings All Data Locally)

Filter(SharePointList, Status = "Active")

Retrieves all records first, then filters in Power Apps.

✅ Good Practice (Delegable, Fetches Only Required Data)

Filter(SharePointList, StatusColumn = "Active")

Queries only filtered data directly from SharePoint.
Faster and reduces API calls.

2.4 Batch Process API Calls Instead of Calling for Each Record

If you need to update multiple records, use ForAll() with Patch() instead of multiple API calls.

❌ Bad Practice (Separate API Call for Each Update)

ForAll(MyCollection, Patch(Orders, ThisRecord, {Status: "Completed"}))

Each record update sends a separate API call → Slow and inefficient.

✅ Good Practice (Batch Process API Calls)

Patch(Orders, MyCollection)

Updates all records in one API call.
Drastically improves performance.

2.5 Cache Data for Offline or Repeated Use

Cache data that doesn’t change frequently instead of reloading it repeatedly.

Step 1: Store Data in Power Apps Storage

SaveData(MyDataCollection, "LocalData")

Saves MyDataCollection locally on the device.

Step 2: Load Cached Data Instead of API Calls

LoadData(MyDataCollection, "LocalData", true)

✅ Prevents unnecessary API requests when offline or when reopening the app.

2.6 Optimize Data Queries by Selecting Only Required Columns

Instead of retrieving all columns, fetch only the necessary fields to reduce API call size.

❌ Bad Practice (Retrieves All Columns, Even Unused Ones)

ClearCollect(MyData, APIDataSource)

Brings unnecessary data, increasing API load.

✅ Good Practice (Retrieve Only Needed Columns)

ClearCollect(MyData, ShowColumns(APIDataSource, "ID", "Title", "Status"))

Reduces data payload and API call execution time.

2.7 Use Lazy Loading Instead of Fetching All Data

Instead of fetching thousands of records at once, load data in smaller chunks.

Step 1: Fetch Data in Chunks

ClearCollect(ChunkedData, FirstN(APIDataSource, 100))

Loads only 100 records initially.

Step 2: Load More Data When Needed

Collect(ChunkedData, FirstN(Skip(APIDataSource, CountRows(ChunkedData)), 100))

Loads more data when the user scrolls.
✅ Prevents unnecessary API overload.

2.8 Optimize Gallery & Dropdown Controls to Prevent Repeated API Calls

Scenario: A dropdown list retrieves data from an API every time it’s opened.

❌ Bad Practice (Fetching Data on Every Dropdown Open)

Items = APIDataSource

Each time the dropdown opens, it makes an API call.

✅ Good Practice (Load Data Once and Use Collection)

OnVisible = ClearCollect(DropdownData, APIDataSource)
Items = DropdownData

Loads data only once when the screen opens.
Reduces API calls significantly.

2.9 Use Concurrent API Calls to Reduce Load Time

If multiple API calls are needed, use Concurrent() to run them simultaneously instead of sequentially.

Example: Fetching Data from Multiple APIs

Concurrent(
    ClearCollect(Users, APIUserSource),
    ClearCollect(Orders, APIOrderSource),
    ClearCollect(Products, APIProductSource)
)

✅ Speeds up API responses by running them in parallel.

3. Best Practices for Reducing API Calls

✅ Use Collections & Variables → Store API data locally instead of repeated requests.
✅ Enable Delegation → Filter data at the source instead of in Power Apps.
✅ Batch Updates with Patch() → Update multiple records in a single API call.
✅ Cache Data with SaveData() → Reduce API calls for unchanged data.
✅ Lazy Load Data → Fetch data in smaller chunks only when needed.
✅ Minimize Retrieved Columns → Use ShowColumns() to reduce API payload.
✅ Use Concurrent() for Faster API Calls → Run multiple calls simultaneously.

4. Conclusion

Reducing API calls in Power Apps enhances app speed, avoids performance bottlenecks, and prevents throttling. By caching data, optimizing queries, using collections, enabling delegation, and batching updates, you can build high-performance apps that efficiently manage API usage.

Would you like real-world examples or specific optimizations for your data source (SharePoint, SQL, Dataverse, REST API)?