Skip to content
AF

Google Health API access: verification, the 100-user cap and rate limits

Read from Google’s documentation on 2026-10-17 · discovery document revision 20261014 · Google’s app-verification page last updated 2026-09-25

Google’s app-verification page: “If your app isn't verified, it's limited to 100 users.” The verification process has two parts: OAuth app verification by Google’s Trust and Safety team, and an annual third-party security assessment. Google’s default quotas are Per project (daily): 86.4M requests / day; Per project (minutely): 120,000 requests / minute; Per user (minutely): 300 requests / minute; an app over a limit gets 429 Too Many Requests and should back off and retry.

App verification

If your app requests access to sensitive user data using restricted scopes, it must complete a verification process. Most scopes for the Google Health API are restricted, which means you must complete verification before your app is publicly available.

During this process, Google verifies that your app complies with the API Services User Data Policy and any other applicable policies.

If your app isn't verified, it's limited to 100 users. To support more users, you must complete the verification process. This verification is separate from any app review process required by app stores like Google Play. An app that hasn't completed this verification might be listed on the Google Play store, but is still limited to 100 users. For more information, see OAuth App Verification Help Center

The verification process has two parts:

  • OAuth app verification: Google's Trust and Safety team reviews your app's identity, scopes, and other information you provide in the Google Cloud console. See Verification Requirements for more information.
  • Security assessment: Your application must undergo a third-party security assessment to ensure it handles user data securely.

Quoted from Google's app-verification page, last updated 2026-09-25, read 2026-10-17.

Google’s About page words the scope rule more strictly than this page does:

  • Restricted-scope wording differs

    Google's pages word the restricted-scope rule differently: About the Google Health API says "all"; App verification says "most".

    • Google's About page: “All Google Health API scopes are categorized as Restricted, necessitating a privacy and security review for access.”
    • Google's app-verification page: “Most scopes for the Google Health API are restricted, which means you must complete verification before your app is publicly available.”

OAuth app verification

To prepare for verification, review and follow the OAuth 2.0 Restricted Scopes guide. This guide outlines the steps to prepare for and request verification in the Google Cloud console.

Be specific when explaining why your app needs each scope. Vague or duplicate justifications for different scopes can cause delays in the verification process.

In-app disclosure requirements

You must prominently disclose to your users how your app accesses, uses, and shares their health and fitness data.

The in-app disclosure:

  • Must be within the app itself, not only in the app description or on a website.
  • Must be displayed in the normal usage of the app and not require the user to navigate into a menu or settings.
  • Must describe the data being accessed or collected.
  • Must explain how the data is used or shared.
  • Cannot only be placed in a privacy policy or terms of service.
  • Cannot be included with other disclosures unrelated to Google Health API data collection.

Here is a recommended format for the disclosure statement: "{App name} collects health and fitness data to enable {feature}, {feature}, and {feature}."

For example: "Fitness Coach collects activity data to enable analytics and personalized coaching."

Quoted from Google's app-verification page, last updated 2026-09-25, read 2026-10-17.

Security assessment (CASA)

In addition to OAuth verification, apps using restricted scopes must also complete an annual security assessment based on the Cloud App Security Assessment framework (CASA). Google's Trust and Safety team notifies you with instructions when this needs to be completed.

A third-party security firm performs this assessment to confirm that your app handles user data securely and can delete user data upon request. CASA uses the industry-recognized OWASP Application Security Verification Standard (ASVS). After you pass the assessment, your app receives a Letter of Validation (LOV) from the security assessor.

For more details on the CASA program and to find authorized security assessors, visit the Cloud Application Security Assessment website.

If you have existing security certifications or recent penetration test results that align with accepted industry standards, you might be able to expedite the CASA process. CASA offers an Accelerator program that lets assessors use existing valid documentation from Accepted Security Frameworks to reduce redundant checks and potentially lower assessment costs.

Google accepts HITRUST, SOC 2, and ISO/IEC 27001 certifications that you have already completed. To use these certifications, you must still work with an authorized CASA assessor and provide your completed HITRUST, SOC 2, or ISO/IEC 27001 documentation. The CASA assessor checks off these certifications against their list of CASA requirements, which reduces the time required to complete the CASA assessment.

The security assessment can take 2-3 weeks for tier-2 applications and 4-6 weeks for tier-3 applications to complete and involves fees payable to the third-party assessor, ranging from $500 to $4,500 USD, depending on your app's complexity. Trust and Safety will tell the developer when to start the CASA process.

After you get your Letter of Validation (LOV), submit the letter to Google's Trust and Safety team to complete your security assessment.

Quoted from Google's app-verification page, last updated 2026-09-25, read 2026-10-17.

Escalations

The CASA assessment is performed by a third party, and Google does not have control over this assessment process. Any issues with the assessment should be raised directly with your chosen security assessor.

Quoted from Google's app-verification page, last updated 2026-09-25, read 2026-10-17.

Rate limits

To ensure system stability and equitable resource distribution, the Google Health API enforces rate limits on incoming API requests. Google’s table, verbatim:

MetricDefault limitGoogle’s QPS impact analysis
Per project (daily)86.4M requests / day~1,000 QPS sustained
Per project (minutely)120,000 requests / minute~2,000 QPS burst
Per user (minutely)300 requests / minuteStandard: 5 QPS per user
Unverified applications: Max 250 QPS total (capped at 100 users @ 2.5 QPS per user)

From Google’s rate-limits page, last updated 2026-05-18, read 2026-10-17.

Handling a 429

When your application exceeds an allocated rate limit, the API rejects the request and returns the error 429 Too Many Requests. To mitigate the error, your application should backoff sending requests and implement retry logic to gracefully handle rate-limiting events.

Quoted from Google's rate-limits page, last updated 2026-05-18, read 2026-10-17.

Asking for more quota

If your application requires higher throughput than the default allocations provided, you can request an adjustment through the Google Cloud Console. See View and manage quotas.

Quoted from Google's rate-limits page, last updated 2026-05-18, read 2026-10-17.

Querying history within the limits

One of the core benefits of the Google Health API is the ability to track a user's performance and monitor their health vitals over long periods of time. You can query a user's data as far back as it has been recorded; the API imposes no limitations or restrictions on the amount of historical data your application can consume.

However, querying historical data is still governed by standard rate limits. To manage system stability and prevent excessive payloads, the Google Health API uses automatic pagination with endpoint-specific page sizes. Note the following boundaries and behavior:

  • Automatic pagination: If you query a long span of data, the API will only return the first page of results up to the page size cap for that endpoint, along with a nextPageToken. You must use the nextPageToken to request subsequent pages.
  • Variable page sizes: Capping limits depend on the endpoint and data type. For most data types, page sizes are capped at a maximum of 10,000. However, for certain data types like exercise and sleep, the default and maximum page size is capped at 25. For example, if a client requests all sleep data for the past 10 years, the API will still return only 25 sleep sessions on the first page.
  • Rollup date range restrictions: For data rollup and aggregation endpoints (such as rollUp and dailyRollUp), query date ranges are restricted based on the data type:
    • A maximum range of 14 days for calories-in-heart-rate-zone, heart-rate, active-minutes, and total-calories.
    • A maximum range of 90 days for all other rollup data types.

Depending on the volume of historical data your application needs, retrieving the entire dataset will require paginating through the pages sequentially. Keep this in mind when designing your application's data synchronization process.

To ensure optimal performance and avoid API errors, follow these guidelines when querying historical data:

Phased data sync (hot versus cold load)

  • Initial "hot" load: Fetch and render only the most recent 7–14 days of data during the primary load sequence. This ensures that users see data immediately without waiting for long-running queries.
  • Background "cold" load: Delegate older historical data retrieval to an asynchronous, lower-priority queue or background process after the primary UI is rendered.

Query chunking for aggregation

  • Because rollup and daily rollup endpoints enforce a maximum date range limit (14 or 90 days depending on the data type), you must break down large historical aggregation queries into smaller, sequential intervals within these limits.
  • Batch or sequence these sub-queries safely to respect concurrency limits and maintain steady UI progress indicators.

Resilient error handling (smart retries)

  • Implement strict exponential backoff handling when encountering rate limits (429 Too Many Requests) and server gateway timeouts (504 Gateway Timeout). Never retry large, failed payloads immediately. Instant retries multiply backend congestion and compound system degradation.
Warning: Not following these guidelines can introduce unexpected behavior and errors.

Quoted from Google's endpoints guide, last updated 2026-10-05, read 2026-10-17.

In the v4 error catalog the status is RESOURCE_EXHAUSTED (HTTP 429): “Quota exceeded or rate limited.” every error reason.

Which scopes are restricted, and what each covers: Google Health API scopes. What the Fitbit Web API’s own limits were: the Fitbit 429 rate-limit page.

Questions

How many users can an unverified Google Health API app have?

100. Google's app-verification page: "If your app isn't verified, it's limited to 100 users." It adds: "An app that hasn't completed this verification might be listed on the Google Play store, but is still limited to 100 users." The rate-limits page also caps unverified applications in its per-user row: "Unverified applications: Max 250 QPS total (capped at 100 users @ 2.5 QPS per user)"

What are the Google Health API rate limits?

Google's default limits, from its rate-limits page (last updated 2026-05-18): Per project (daily): 86.4M requests / day; Per project (minutely): 120,000 requests / minute; Per user (minutely): 300 requests / minute. Rate limits are evaluated across daily, minutely, and per-user intervals.

Does a Google Health API app need a CASA security assessment?

Yes, if it uses restricted scopes. Google's app-verification page: "In addition to OAuth verification, apps using restricted scopes must also complete an annual security assessment based on the Cloud App Security Assessment framework (CASA)." After you pass the assessment, your app receives a Letter of Validation (LOV) from the security assessor.

What should an app do when the Google Health API returns 429?

Back off and retry. Google's rate-limits page: "When your application exceeds an allocated rate limit, the API rejects the request and returns the error 429 Too Many Requests. To mitigate the error, your application should backoff sending requests and implement retry logic to gracefully handle rate-limiting events." Its endpoints guide: "Implement strict exponential backoff handling when encountering rate limits (429 Too Many Requests) and server gateway timeouts (504 Gateway Timeout). Never retry large, failed payloads immediately. Instant retries multiply backend congestion and compound system degradation." The v4 error catalog lists RESOURCE_EXHAUSTED with HTTP 429: "Quota exceeded or rate limited."

Can you raise the Google Health API quota?

Yes, by request. Google's rate-limits page: "If your application requires higher throughput than the default allocations provided, you can request an adjustment through the Google Cloud Console."

Sources checked

Google’s text is quoted for identification; each guide page’s footer reads: “Except as otherwise noted, the content of this page is licensed under the Creative Commons Attribution 4.0 License, and code samples are licensed under the Apache 2.0 License.”. Generated from Google’s pages by scripts/fetch-google-health-api.mjs, not typed by hand; Google’s documentation remains the authority.