Best Practices for Intuit API Optimization: Part 1

When building integrations with QuickBooks Online, one of the biggest decisions you’ll need to make is how to manage data syncing in an efficient and cost-effective way.

Given the recent changes to the metering of certain API calls under the new Core and CorePlus categories in the Intuit App Partner Program, optimizing your app integration for performance and cost control is now more important than ever.

In Part 1 of our series “Best Practices for Intuit API Optimization,” we’ll guide you through a strategy for using some key Intuit-provided API endpoints to refine your sync architecture. Prefer to watch instead? Check out a video replay of the July 10, 2025 office hours session we hosted on this.

Step 1: Understand how QuickBooks Online APIs are categorized

The first step in building a smarter integration is understanding the API classification model under the App Partner Program. At a high level, QuickBooks Online APIs are grouped into two categories:

• Core APIs are focused on data-in operations such as creating or updating invoices. These calls are currently unmetered, meaning you won’t be charged based on usage.
• CorePlus APIs primarily handle data-out operations such as reading accounts and querying company information. These can be metered, and charges may apply depending on usage.

Currently, only the QuickBooks Accounting API is metered. APIs for Payments, Desktop, Payroll, and all OAuth and Sandbox endpoints aren’t subject to usage fees.

To monitor your app’s usage, check out the API usage chart in your Intuit Developer account. You can learn more about reviewing your API usage in this article.

Step 2: Evaluate your app’s sync behavior

Every app is different. Before you start refactoring anything, it’s essential to review your business processes and the frequency with which your data changes.

Some data entities are relatively stable. For example, terms, classes, departments, and the chart of accounts rarely change once they’re set up. Other data entities like invoices, expenses, and items change frequently and require timely syncs.

Understanding these patterns helps you determine where to apply caching, when to fetch updates, and which APIs are worth polling (if any at all).

Step 3: Rethink how you sync

Many apps follow one of two sync models:

1. User-initiated sync

These syncs are triggered when a user clicks a “refresh” button, navigates between tabs, or enters a keyword into the app’s search field. This approach is easy to implement but often results in redundant API calls and sometimes empty responses when the underlying data hasn’t‌ changed.

2. Automated sync

These syncs involve periodic polling—say every few minutes or hours—to fetch data updates. In many cases, apps are configured to fetch large datasets repeatedly, regardless of whether the data has changed. This results in syncs that often lack prioritization, pulling in everything instead of filtering for the most critical or recently updated records. This approach increases your CorePlus API call volume.

We’ve seen both user-initiated and automated syncs that continue running even during periods of low user activity. This results in wasted API calls because only a few meaningful updates are expected. These inefficiencies can quickly add up, especially for apps connected to hundreds or thousands of QuickBooks companies.

To reduce wasted calls and improve performance, you should shift from brute-force syncing to more event-driven, intelligent data flows.

Step 4: Use Intuit tools to optimize syncs

Replace polling with webhooks

Webhooks let your app listen for real-time changes from QuickBooks Online. When something changes—say, a customer is updated, or an invoice is created—your app is notified immediately. No more guessing. No more constant polling.

Here’s a sample webhook payload for an updated Preferences record:

{
  "eventNotifications": [
    {
      "realmId": "310687",
      "dataChangeEvent": {
        "entities": [
          {
            "id": "1234",
            "operation": "Update",
            "name": "Preferences",
            "lastUpdated": "2025-06-26T13:22:50.092Z"
          }
        ]
      }
    }
  ]
}

Once you receive the sample webhook event as shown above, you can decide which of the following your app should do next:

• Fetch the updated record using the ID
• Update your cache or database
• Trigger downstream workflows or user notifications

All of this happens reactively, only when needed.

Switching from polling to webhooks is one of the most impactful upgrades you can make to your QuickBooks integration. It leads to lower API usage and a more scalable architecture. If you’re still polling on a fixed schedule, now is the time to consider making the switch. To get started, check out our Webhooks documentation and begin listening for the changes that matter most to your app.

Use CorePlus APIs efficiently

If you’re working with CorePlus endpoints, make every call count. Instead of making several individual GET requests, try batching or consolidating your API read calls.

BATCH API

The Batch API lets you submit up to 30 operations in a single call. This is ideal when you need to fetch multiple entities at once.

Here’s the endpoint URL you should use:

GET /v3/company/<realmID>/batch

With a single call, you can fetch all of the following entities at the same time:

• Several invoices
• A list of vendors
• Customer profiles
• A few bills that just changed

TIP: Since BATCH calls are metered, prioritize making CorePlus calls via BATCH instead of Core.

CHANGE DATA CAPTURE

The Change Data Capture (CDC) operation returns a list of objects that have changed since a specified time. This operation is for an app that periodically polls data services to refresh its local copy of object data. Here are some key attributes of the CDC operation:

• CDC handles a maximum of 1,000 objects and includes payloads.
• You can query multiple transactions together over a period of time. Look-back time can be up to 30 days.

Call the CDC operation by specifying a comma-separated list of object types and a date-time stamp specifying how far to look back. Use companyid , entityList, and changedSince parameters. For example:

https://{{baseurl}}/v3/company/{{companyid}}/cdc?entities=bill,invoice,customer,vendor,estimate,preferences&changedSince=2025-1-1

You can find additional information on working with the Change CDC operation here.

QUERY API

We understand your app might still use the query operation to get details about a specific API entity. Here are some best practices to help optimize CorePlus API calls while querying:

• Always use filters to pull exactly what you need (e.g., SELECT * FROM Invoice WHERE TxnDate > ‘2025-01-01’). Using filters ensures your queries are precise and efficient, allowing your app to retrieve only the most relevant records. This will reduce the amount of subsequent CorePlus API calls.
• Use the maximum allowable page size, which is 1,000. If MAXRESULTS aren’t specified, the default number is 100. Here’s an example of how to use maxresults to retrieve up to 1,000 invoices starting from the first record:

SELECT * FROM Invoice STARTPOSITION 1 MAXRESULTS 1000

These patterns help you minimize the number of CorePlus calls and avoid unnecessary charges.

Adapt your integration for long-term success

As the QuickBooks Online platform continues to evolve, so should your integration strategy. With a new metering model in place*, optimizing for performance and cost-efficiency is essential.

By rethinking how you sync, embracing event-driven design, and making use of available tools like webhooks, CDC, and Batch APIs, you can create a seamless experience for your users while staying within usage thresholds.

For more tips, code samples, and architecture patterns, check out the Intuit Developer Portal.

*Receiving webhooks is not currently metered

---

Note: The strategies discussed in this post are based on general best practices. We strongly recommend conducting your own evaluation before implementation to ensure they align with your app’s needs.