Google Fit — What It Is, Platform Architecture and APIs

What Is Google Fit?

Google Fit is a health management platform launched by Google in 2014 at the I/O conference. The platform provides a unified API for reading and writing physical activity data, allowing apps to exchange information through a central repository in the Google cloud.

Unlike proprietary solutions, Google Fit works on the Android operating system and iOS via REST API. Users can connect fitness bands, smartwatches and activity tracking apps, and Google Fit aggregates all data into a single health profile in Google Cloud.

According to Google I/O 2024, the platform is used in over 5000 apps worldwide, with active users exceeding 100 million. The platform is integrated with Wear OS and supports all popular fitness trackers through third-party apps.

Google Fit Architecture

Google Fit architecture is built on three layers: client SDK, Google Fitness Store cloud storage, and REST API for server integration. The client SDK is available for Android (Kotlin, Java) and iOS (Swift, Objective-C), and there is also a web client via JavaScript.

Data is organized as sources (DataSource) and data points (DataPoint). Each source represents a device or app, and each data point represents a single measurement with a timestamp. Groups of data points are combined into sessions — continuous periods of activity with a type and duration.

val fitnessClient = Fitness.getClient(activity, GoogleSignIn
    .getAccountForExtension(activity, fitnessOptions))

val stepType = DataType.TYPE_STEP_COUNT_DELTA

val request = DataReadRequest.Builder()
    .read(stepType)
    .setTimeRange(
        startTime, endTime, TimeUnit.MILLISECONDS
    )
    .build()

fitnessClient.readData(request)
    .addOnSuccessListener { response ->
        for (bucket in response.buckets) {
            println(bucket.dataSets)
        }
    }

How Google Fit Works

Google Fit uses a sync model through Google Cloud with support for both online and offline modes. The app records data locally, and the Google Fit SDK automatically syncs it with the cloud storage when an internet connection is available. Conflicts are resolved on a last-write-wins basis.

Each data type has a standardized format: steps — TYPE_STEP_COUNT_DELTA, calories — TYPE_CALORIES_EXPENDED, heart rate — TYPE_HEART_RATE_BPM, distance — TYPE_DISTANCE_DELTA. For custom types, you can create custom DataType through the Google APIs Console with a unique namespace.

The platform supports two recording modes: active — the app explicitly calls HistoryClient.insertData(), and passive — via RecordingClient, which subscribes to data collection in the background. Passive mode is convenient for fitness apps: the user launches the app once, and Google Fit automatically collects steps, calories and distance while the app is minimized, without constant CPU usage.

According to Google, the platform processes over 2 billion data points daily. Average sync latency is 5–10 seconds with an active connection, and in background mode sync occurs every 30 minutes to save battery life.

User Consent and Security

Google Fit uses OAuth 2.0 for authorization with access scopes fitness.activity.read, fitness.activity.write, fitness.body.read and fitness.body.write. The app requests only necessary scopes, and the user confirms access through the standard Google Sign-In dialog with account selection.

The user can revoke access at any time through Google Account Permissions or the Google Fit app. Google strictly prohibits sharing health data with third parties without explicit consent, as well as using data for advertising purposes in accordance with the Restricted Scopes policy.

Google Fit APIs

Google Fit provides three main APIs: Fitness API for reading and writing historical data, Sensors API for real-time streaming data from sensors, and Sessions API for managing activity sessions. Each API is available both through the Android SDK and via REST requests.

Fitness API — the main API for working with data. It supports batch operations: writing up to 1000 data points in a single call, reading with filtering by time range, data type and source. For data aggregation, DataSet is used with grouping by selected metrics.

Sensors API allows subscribing to real-time sensor data — steps, heart rate, acceleration. Data is received via SensorEventListener at a frequency determined by the sensor type and app settings.

In addition to the three main APIs, Google Fit provides Recording API for automatic data collection without needing to keep the app active. This API is especially valuable for Wear OS: smartwatches can collect heart rate and activity data, and the phone app syncs with them when connected. Recording API uses Google Fit Background Services, which are optimized for minimal power consumption — up to 2% battery per day with passive step collection.

REST API Google Fit is available at the fitness.googleapis.com endpoint. REST API allows server applications to read and write data on behalf of the user after OAuth authorization. This is useful for web analytics dashboards, corporate fitness programs and medical systems that require centralized storage of employee or patient health data.

val recordingClient = Fitness
    .getRecordingClient(activity, googleSignInAccount)

recordingClient.subscribe(DataType.TYPE_STEP_COUNT_DELTA)
    .addOnSuccessListener {
        println("Subscription active")
    }

// Getting history data
val historyClient = Fitness
    .getHistoryClient(activity, googleSignInAccount)

val endTime = Calendar.getInstance().timeInMillis
val startTime = endTime - TimeUnit
    .DAYS.toMillis(7)

historyClient.readDailyTotal(DataType.TYPE_STEP_COUNT_DELTA)
    .addOnSuccessListener { total ->
        println("Steps today: $total")
    }

Integrating Google Fit into an App

Google Fit integration starts with adding dependencies for the Google Fit SDK via build.gradle: com.google.android.gms:play-services-fitness. After that, you need to configure the Google APIs Console — create a project, enable the Fitness API and add OAuth 2.0 credentials with the correct SHA-1 fingerprints.

The integration process includes: initializing GoogleSignIn with the required scopes, creating a FitnessClient via Fitness.getClient(), requesting user authorization, and performing read or write data operations. For background recording, RecordingClient is used, which automatically collects data even when the app is minimized. Google Fit automatically manages data collection frequency based on battery level and user activity.

According to Google, apps with Google Fit integration show 35% higher user retention rates. Key app categories — fitness trackers, running, cycling, yoga and weight control apps.

It is important to consider privacy requirements: Google Fit uses Restricted Scopes — special access scopes that require separate app verification through OAuth Verification. The developer must describe what data is collected, how it is used and how long it is stored. Google also requires a privacy policy and compliance with the API Services Terms of Service.

Practical Recording Example

To record data, a DataSource is created with the type, device and app specified. Then a DataPoint is created with a timestamp and values. Multiple DataPoints are combined into a DataSet, which is passed to HistoryClient.write().

val dataSource = DataSource.Builder()
    .setAppPackageName(activity)
    .setDataType(DataType.TYPE_STEP_COUNT_DELTA)
    .setType(DataSource.TYPE_RAW)
    .build()

val stepCount = DataPoint.builder(dataSource)
    .setTimestamp(now, TimeUnit.MILLISECONDS)
    .setField(Field.FIELD_STEPS, 500)
    .build()

val dataSet = DataSet.builder(dataSource)
    .add(stepCount)
    .build()

historyClient.insertData(dataSet)
    .addOnSuccessListener {
        println("Data saved")
    }