Google Health API for Apps: Supported Data Types, EHR/EMR Integration, and Implementation Guide

If you are building a healthcare app, wellness platform, remote patient monitoring product, or digital therapeutics workflow, the Google Health API creates a cleaner path to bring patient-generated health data into your application.

And if your product also needs to connect with EHR and EMR systems, the real opportunity is not just reading steps or sleep data. It is building a secure pipeline that turns wearable and self-reported data into clinically useful context.

This guide covers:

• What the Google Health API is
• The main data types it supports
• How to integrate it into mobile and web apps
• How to connect that data to EHR and EMR systems
• Security, consent, and compliance considerations

As of July 23, 2026, Google's official documentation shows a broad set of fitness, sleep, nutrition, and health metric data types, along with OAuth scopes, REST endpoints, and webhook support for selected records.

What is the Google Health API?

The Google Health API is Google's modern REST-based health data platform for authorized third-party applications. It uses Google OAuth for consent and access control, supports multiple health-related scopes, and exposes data through standardized REST endpoints.

From the official docs, the API emphasizes:

• Google OAuth-based consent and security
• Scalable access to health and fitness records
• Standard REST conventions
• Support for webhooks instead of constant polling
• Long-term historical data access with paginated retrieval

In practical terms, this means an app can request a user's consent, read approved health datasets, normalize them in its backend, and use them for experiences like:

• Remote patient monitoring
• Diabetes tracking
• Fitness and recovery dashboards
• Chronic care engagement
• Preventive care alerts
• Insurance wellness programs
• Employer wellness apps
• Provider-facing care coordination workflows

Why the Google Health API matters for healthcare apps

Most healthcare organizations now need data from more than one source:

• Clinical systems hold diagnoses, encounters, medications, lab orders, and physician notes
• Consumer devices and apps hold activity, sleep, weight, heart rate, hydration, and other lifestyle signals

That second category is where the Google Health API becomes valuable.

It helps bridge the gap between:

• what happens inside the clinic, and
• what happens between visits

That is especially useful for:

• obesity and weight management apps
• cardiology follow-up apps
• diabetes care workflows
• recovery and rehabilitation platforms
• preventive health dashboards
• population health engagement tools

Supported Google Health API data types

Based on Google's official data types documentation, the API supports a wide range of data across activity and fitness, health metrics and measurements, nutrition, sleep, ECG, and irregular rhythm notifications.

1. Activity and fitness data

These records are useful for wellness apps, employer health programs, cardiac rehab, preventive care, and engagement scoring.

Supported activity and fitness data types include:

• Active Energy Burned
• Active Minutes
• Active Zone Minutes
• Activity Level
• Altitude
• Calories in Heart Rate Zone
• Daily VO2 Max
• Distance
• Exercise
• Floors
• Run VO2 Max
• Sedentary Period
• Steps
• Swim Lengths Data
• Time in Heart Rate Zone
• Total Calories
• VO2 Max

App use cases:

• daily movement goals
• post-discharge mobility tracking
• rehab adherence monitoring
• fitness readiness scoring
• patient engagement and behavioral nudges

2. Health metrics and measurements

This category is especially relevant to RPM, chronic care, and clinical review workflows.

Supported health metrics and measurement data types include:

• Blood Glucose
• Body Fat
• Core Body Temperature
• Daily Heart Rate Variability
• Daily Heart Rate Zones
• Daily Oxygen Saturation
• Daily Respiratory Rate
• Daily Resting Heart Rate
• Daily Sleep Temperature Derivations
• Heart Rate
• Heart Rate Variability
• Height
• Oxygen Saturation
• Respiratory Rate Sleep Summary
• Weight

App use cases:

• diabetic monitoring workflows
• pulse-ox monitoring
• care-plan adherence dashboards
• weight management programs
• chronic condition trend analysis

3. Nutrition and hydration data

These data types help nutrition apps, disease management platforms, and digital coaching products.

Supported nutrition-related data types include:

• Food
• Food Measurement Unit
• Hydration Log
• Nutrition Log

App use cases:

• calorie and macro tracking
• hydration coaching
• clinician-reviewed nutrition plans
• renal, cardiac, or diabetes diet programs

4. Sleep data

Sleep is often one of the strongest signals for recovery, stress, and disease management.

Supported sleep-related data types include:

• Sleep
• Daily Sleep Temperature Derivations
• Respiratory Rate Sleep Summary

App use cases:

• recovery monitoring
• sleep quality dashboards
• behavioral health support
• chronic condition risk scoring

5. ECG and rhythm-related data

For cardiovascular and higher-acuity use cases, Google also documents support for:

• Electrocardiogram (ECG)
• Irregular Rhythm Notification

These are especially relevant when your app needs to surface patient-generated rhythm data to a clinician or trigger further review.

Important implementation details from Google's docs

There are a few technical details worth highlighting before you start architecture work.

Naming conventions

Google uses different identifier styles depending on where the data type appears:

• endpoint paths use kebab-case such as body-fat
• filter parameters use snake_case such as body_fat

That detail matters when building generic query builders or data sync services.

Query window limits

According to the official docs:

• some high-volume data types such as heart-rate, active-minutes, calories-in-heart-rate-zone, and total-calories have a 14-day maximum query range
• most other data types have a 90-day maximum query range

Historical data access

Google notes that applications can query data as far back as it has been recorded, but retrieval is still governed by pagination and rate limits.

Pagination

The docs state that each endpoint can return up to 10,000 data points per page, which matters for backfills and longitudinal health analytics.

Webhook support

Webhook subscriptions are available for selected data types, which is useful when you want near-real-time updates without heavy polling.

How to integrate the Google Health API into an app

At a high level, the integration pattern looks like this:

Step 1: Define your use case first

Before touching OAuth scopes, decide what the product actually needs.

Examples:

• A weight-loss app may need weight, nutrition, hydration, activity, and sleep
• A diabetes support app may need blood glucose, activity, nutrition, and weight
• A cardiology monitoring app may need heart rate, oxygen saturation, sleep, exercise, ECG, and irregular rhythm notifications

This helps you avoid over-requesting permissions.

Step 2: Request only the required scopes

The official docs recommend requesting only the scopes your app truly needs and handling partial consent gracefully.

Examples of scope families include:

• googlehealth.activity_and_fitness
• googlehealth.health_metrics_and_measurements
• googlehealth.ecg
• googlehealth.irn

If your app writes data back, use the appropriate write-enabled scopes only for that use case.

Step 3: Build a sync service, not just frontend calls

For production healthcare apps, do not rely on the frontend alone. Put a backend service between Google Health and your product.

That service should handle:

• OAuth token lifecycle
• data normalization
• deduplication
• patient identity mapping
• webhook processing
• audit logging
• retry logic
• EHR/EMR export rules

Step 4: Normalize records into a domain model

Google Health data should not flow raw into your product tables.

Create a normalized internal model such as:

• patient_metric
• activity_summary
• sleep_session
• nutrition_entry
• device_event
• clinical_export_queue

This gives you flexibility when integrating with multiple devices, EHR vendors, and payer systems later.

Step 5: Use webhooks for incremental sync

If your data type supports webhooks, subscribe so your backend can react to updates instead of re-querying everything repeatedly.

This is particularly useful for:

• daily care dashboards
• provider alerts
• RPM review queues
• adherence notifications

How the Google Health API connects with EHR and EMR systems

This is where many teams get the architecture wrong.

The Google Health API is not your EHR. It is a consumer health data source.

That means the right design is usually:

1. collect patient-authorized data from Google Health
2. validate and normalize it in your integration layer
3. map the relevant records into FHIR or another clinical interchange format
4. push only the clinically appropriate subset into the EHR/EMR

The simplest mental model

Think of the stack like this:

• Google Health API = patient-generated health data source
• Your app/backend = orchestration, consent, business logic, auditing, analytics
• FHIR/HL7 integration layer = interoperability bridge
• EHR/EMR = clinical system of record

When should Google Health data go into an EHR?

Not every metric belongs in the medical record.

Good candidates include:

• weight trends for weight management or CHF follow-up
• blood glucose readings for diabetes workflows
• oxygen saturation trends for respiratory monitoring
• resting heart rate or HRV trends for care programs
• sleep summaries for specific clinician-reviewed care pathways

Less useful candidates for direct EHR writeback may include:

• every step event
• raw activity bursts
• every hydration entry

Those often work better in your application layer, with summarized clinical exports only when needed.

EHR/EMR integration patterns that work well

1. FHIR-first integration

This is usually the best modern option.

Map selected Google Health records into resources such as:

• Observation for weight, blood glucose, oxygen saturation, heart rate, respiratory rate, body fat, and temperature
• DocumentReference or vendor-specific cardiology workflows for ECG-related artifacts
• Patient and RelatedPerson linkages for identity context
• CarePlan or task-driven workflows when the data should trigger follow-up actions

For patient-generated health data, many teams create a separate ingestion pipeline that labels the source clearly so clinicians know it came from a consumer device or patient entry rather than an in-clinic calibrated device.

2. EMR middleware pattern

If the provider uses an older EMR or HL7-heavy stack, insert middleware between your app and the clinical system.

That middleware can:

• translate normalized records into FHIR, HL7 v2, or vendor-specific APIs
• apply data quality rules
• suppress non-clinical noise
• batch updates into review-friendly summaries

This pattern is common in hospitals that still run mixed legacy systems.

3. Clinical review queue pattern

For many healthcare apps, the best approach is not automatic writeback.

Instead:

• your backend ingests Google Health data
• rules detect threshold breaches or trends
• flagged items enter a nurse or care-coordinator review queue
• approved summaries are pushed into the EHR

This reduces alert fatigue and keeps the chart cleaner.

Example: mapping Google Health data into FHIR

Here is a simplified example of converting a Google Health weight reading into a FHIR Observation.

Copy
1{
2  "resourceType": "Observation",
3  "status": "final",
4  "category": [
5    {
6      "coding": [
7        {
8          "system": "http://terminology.hl7.org/CodeSystem/observation-category",
9          "code": "vital-signs",
10          "display": "Vital Signs"
11        }
12      ]
13    }
14  ],
15  "code": {
16    "coding": [
17      {
18        "system": "http://loinc.org",
19        "code": "29463-7",
20        "display": "Body weight"
21      }
22    ]
23  },
24  "subject": {
25    "reference": "Patient/12345"
26  },
27  "effectiveDateTime": "2026-07-22T07:10:00Z",
28  "valueQuantity": {
29    "value": 78.4,
30    "unit": "kg",
31    "system": "http://unitsofmeasure.org",
32    "code": "kg"
33  },
34  "note": [
35    {
36      "text": "Patient-generated data imported from Google Health API via authorized application."
37    }
38  ]
39}

That same pattern can be adapted for:

• blood glucose
• pulse oximetry
• heart rate
• temperature
• respiratory rate

Example backend flow for app + EHR integration

Copy
1type GoogleHealthMetric = {
2  userId: string;
3  dataType: string;
4  value: number;
5  unit: string;
6  recordedAt: string;
7};
8
9async function processGoogleHealthMetric(metric: GoogleHealthMetric) {
10  const patient = await matchPatientByConsent(metric.userId);
11  if (!patient) throw new Error("No patient mapping found");
12
13  const normalized = await normalizeMetric(metric);
14  const shouldExport = await evaluateClinicalExportPolicy(normalized);
15
16  await saveMetric(normalized);
17
18  if (!shouldExport) return;
19
20  const fhirObservation = mapToFhirObservation(patient.fhirPatientId, normalized);
21  await sendToEhrFhirServer(fhirObservation);
22  await writeAuditLog({
23    source: "google-health-api",
24    patientId: patient.id,
25    dataType: metric.dataType,
26    exportedAt: new Date().toISOString(),
27  });
28}

This is a better production pattern than pushing every event directly into the EHR.

Recommended architecture for healthcare apps

If you want your integration to survive real-world scale, build for these concerns from the start.

1. Consent and patient identity mapping

You need a reliable way to connect:

• Google-authorized user
• your app user
• clinical patient identity in the EHR/EMR

Never assume those are automatically the same.

Use a dedicated consent ledger with:

• patient identifier mapping
• source-system identifiers
• consent scope history
• revocation timestamps
• audit metadata

2. Data quality and provenance

Clinicians need to know:

• where the data came from
• whether it was manually entered or device synced
• whether it is raw, derived, or summarized
• how recent it is

That provenance should travel with the record.

3. Rules before writeback

Do not indiscriminately dump consumer data into the chart.

Use rules such as:

• export only daily summaries
• export only threshold exceptions
• export only clinician-reviewed records
• export only for enrolled RPM patients

4. Compliance and retention

Healthcare data is never just an API problem.

Your platform should also define:

• encryption at rest and in transit
• minimum necessary access
• role-based access control
• business associate agreements where applicable
• audit trails
• retention and deletion policies

Google's docs note OAuth-based security and privacy alignment, but your application still owns the downstream compliance burden.

Security and HIPAA-aware considerations

If your app touches protected health information, treat the integration as a regulated workflow from day one.

Key practices:

• request only the minimum scopes required
• store tokens securely and rotate secrets
• isolate healthcare data pipelines from general product analytics
• log access and export events
• separate patient-generated data from clinician-entered data where appropriate
• make consent screens and privacy disclosures extremely clear

Also remember that the presence of consumer health data in your platform does not automatically mean every downstream system should receive it.

Common use cases by product type

Remote patient monitoring app

Use Google Health data for:

• weight trends
• heart rate trends
• oxygen saturation snapshots
• sleep and recovery monitoring

Then export threshold-based summaries into the EHR for care-team review.

Diabetes management app

Use:

• blood glucose
• nutrition logs
• hydration logs
• activity levels
• weight

This can power clinician review dashboards, behavioral coaching, and patient adherence workflows.

Cardiology or recovery app

Use:

• heart rate
• heart rate variability
• oxygen saturation
• exercise sessions
• ECG or irregular rhythm related data where applicable

Then apply alert rules and route clinically meaningful events into the provider workflow.

Employer wellness or consumer health app

Use:

• steps
• active minutes
• sleep
• calories
• hydration

In this model, EHR integration may be optional, while engagement analytics become the main value driver.

SEO-rich FAQ: Google Health API for healthcare apps

Is the Google Health API useful for EHR or EMR integration?

Yes, but usually indirectly. The Google Health API works best as a source of patient-generated health data that your platform normalizes and then maps into EHR/EMR-compatible formats such as FHIR.

Can I send wearable data directly into Epic, Cerner, athenahealth, or another EMR?

Usually not as a raw one-to-one feed. The better pattern is to transform selected metrics into clinically relevant summaries or FHIR Observation resources, then route them through a secure integration layer.

What data types are most useful for clinical workflows?

The most clinically useful data types often include weight, blood glucose, oxygen saturation, heart rate, respiratory rate, and selected sleep or ECG-related records, depending on the care program.

Does the Google Health API support real-time updates?

It supports webhook subscriptions for selected data types, which allows your backend to receive update notifications instead of relying only on polling.

Is the Google Health API only for fitness apps?

No. It is also relevant for remote patient monitoring, chronic care management, digital therapeutics, preventive care, engagement platforms, and provider-connected patient apps.

Do I need FHIR for EHR integration?

If you are integrating with modern healthcare systems, FHIR should be your default choice whenever possible. It reduces vendor lock-in and makes your interoperability layer easier to maintain.

Final thoughts

The real value of the Google Health API is not just that it exposes steps, sleep, and vitals. It is that it gives digital health teams a usable way to connect consumer health behavior with clinical workflows.

If you design the architecture well, you can build:

• better patient engagement
• smarter care-program monitoring
• cleaner RPM workflows
• more actionable clinician dashboards
• safer EHR/EMR integrations

The winning pattern is simple:

• use Google Health as the authorized data source
• use your backend as the control plane
• use FHIR or middleware as the clinical bridge
• keep the EHR as the system of record

That is how you turn wearable and patient-entered data into something healthcare teams can actually use.

Sources

• Google Health API data types
• Google Health API get started
• Google Health API scopes
• Google Health API endpoints
• Google Health API webhook subscriptions