Syncing Fitbit/Apple Health Data to Google Sheets

Hey team, Darian here. A few months back, I found myself manually exporting my Fitbit step counts and sleep data into a spreadsheet every Sunday. It was a tedious, 20-minute task I did to track my fitness goals. As a DevOps engineer, I knew there had to be a better way. Automating this flow not only saved me that time but also gave me a real-time dashboard of my health metrics. It’s a small project, but the value is huge. Let’s walk through how you can build a similar pipeline. This is a great weekend project that pays dividends in saved time and better data visibility.

Prerequisites

Before we dive in, make sure you have the following ready to go:

• A Python 3 environment.
• A Fitbit Developer account or a method to export Apple Health data (often via a third-party app with an API, as direct access is tricky). We’ll focus on Fitbit here, but the principles apply to any API.
• A Google Cloud Platform (GCP) account with the Google Sheets and Google Drive APIs enabled.
• Your favorite code editor.

The Step-by-Step Guide

Step 1: The API Credential Dance

The first and most critical step is getting your digital keys. This is where most people get tripped up, so take your time here. You’ll need to generate credentials for both Google Cloud and your health data provider.

1. For Google Sheets: Head to your GCP console, create a new project, and enable the “Google Sheets API” and “Google Drive API”. Then, create a Service Account. Download the JSON key file that it generates. This file is your password; treat it like one. Rename it to something simple like client_secret.json.
2. For Fitbit: Go to the Fitbit Developer portal, register a new application, and set the type to “Server”. For the callback URL, you can temporarily use http://127.0.0.1:8080 for local testing. Fitbit will give you a Client ID and a Client Secret.
3. Store Your Secrets: Create a file named config.env in your project directory to hold these secrets. Never commit credentials to version control.

Pro Tip: When you create your Google Sheet, you MUST share it with the client_email address found inside your client_secret.json file, giving it “Editor” permissions. Otherwise, your script will get a permission denied error.

Step 2: Project Setup and Dependencies

I’ll skip the standard virtualenv setup since you likely have your own workflow for that. Let’s jump straight to the Python logic. First, create a project directory. Inside, you’ll have your main Python script (e.g., sync_script.py), your client_secret.json, and your config.env file.

You’ll need a few Python libraries to make this work. In your terminal, you’ll want to install the necessary packages for interacting with Google Sheets, handling data, and connecting to the Fitbit API. I typically use libraries like gspread, pandas, and fitbit. A simple requirements.txt file is great for managing these.

Step 3: Authenticating with Python

Now, let’s write some code. The first part of our script will handle authentication. We need to read our secrets and establish a connection with both services. For Google, we’ll use the service account file. For Fitbit, it’s an OAuth2 flow, which can be tricky. The first time you run it, you’ll need to follow a URL in your terminal to authorize the app, but the resulting token can be refreshed automatically after that.

import gspread
import pandas as pd
from oauth2client.service_account import ServiceAccountCredentials
import fitbit
import os
from datetime import date

# --- CONFIGURATION (In a real app, use a proper config library) ---
FITBIT_CLIENT_ID = 'YOUR_CLIENT_ID_HERE'
FITBIT_CLIENT_SECRET = 'YOUR_CLIENT_SECRET_HERE'
# Note: You will need to get ACCESS_TOKEN and REFRESH_TOKEN after the first auth run
FITBIT_ACCESS_TOKEN = 'YOUR_ACCESS_TOKEN'
FITBIT_REFRESH_TOKEN = 'YOUR_REFRESH_TOKEN'

# --- AUTHENTICATION ---
def get_gspread_client():
    """Authenticates with Google Sheets API."""
    scope = ['https://www.googleapis.com/auth/spreadsheets', 'https://www.googleapis.com/auth/drive']
    creds = ServiceAccountCredentials.from_json_keyfile_name('client_secret.json', scope)
    client = gspread.authorize(creds)
    return client

def get_fitbit_client():
    """Authenticates with Fitbit API and returns an authorized client."""
    # This assumes you have already completed the initial OAuth2 flow
    # and have stored your access and refresh tokens.
    client = fitbit.Fitbit(
        FITBIT_CLIENT_ID,
        FITBIT_CLIENT_SECRET,
        oauth2=True,
        access_token=FITBIT_ACCESS_TOKEN,
        refresh_token=FITBIT_REFRESH_TOKEN
    )
    # The client will automatically handle token refreshes if needed.
    return client

Step 4: Fetching and Processing the Data

Once authenticated, we can ask the Fitbit API for data. I’m usually interested in daily activity summaries like steps, distance, and sleep. The API returns this data in JSON format, which I find easiest to work with by loading it into a pandas DataFrame. This makes cleaning, structuring, and preparing the data for Google Sheets incredibly simple.

Pro Tip: Always be mindful of timezones. APIs often return data in UTC. I recommend converting timestamps to your local timezone during the processing step to avoid confusion when you’re looking at the spreadsheet later.

def fetch_fitbit_data(client, day):
    """Fetches daily activity summary from Fitbit."""
    try:
        activity = client.activities(date=day)
        # We can pull out the specific data we want
        summary = activity['summary']
        steps = summary.get('steps', 0)
        distance = summary.get('distances', [{}])[0].get('distance', 0)
        
        # Example of fetching sleep data
        sleep = client.sleep(date=day)
        minutes_asleep = sleep['summary'].get('totalMinutesAsleep', 0)

        return {
            'date': day.strftime('%Y-%m-%d'),
            'steps': steps,
            'distance_km': distance,
            'minutes_asleep': minutes_asleep
        }
    except Exception as e:
        print(f"Error fetching data for {day}: {e}")
        return None

Step 5: Writing to Google Sheets

With our data neatly packaged in a dictionary or DataFrame, the final step is to push it to our spreadsheet. The gspread library makes this a breeze. You open the spreadsheet by its name, select the worksheet you want, and append a new row with your data.

def write_to_sheet(gsheet_client, data):
    """Appends a new row of data to the Google Sheet."""
    if not data:
        print("No data to write.")
        return

    try:
        sheet = gsheet_client.open("My Health Dashboard").worksheet("DailyData")
        # Convert our dictionary to a list in the correct order for the sheet
        # Assuming columns are: Date, Steps, Distance, Sleep
        row_to_add = [data['date'], data['steps'], data['distance_km'], data['minutes_asleep']]
        sheet.append_row(row_to_add)
        print(f"Successfully wrote data for {data['date']} to Google Sheets.")
    except Exception as e:
        print(f"Error writing to Google Sheets: {e}")

# --- Main Execution Logic ---
if __name__ == "__main__":
    today = date.today()
    
    gsheet_client = get_gspread_client()
    fitbit_client = get_fitbit_client()

    daily_data = fetch_fitbit_data(fitbit_client, today)
    write_to_sheet(gsheet_client, daily_data)

Step 6: Automation with Cron

A script is only useful if it runs automatically. In my production setups, I’d use something like a Cloud Function or a GitHub Actions workflow. But for a personal project, a simple cron job is perfect. You can set it to run every night to fetch the previous day’s data.

To edit your cron jobs, you’d typically open your crontab file for editing and add a line like this to run the script at 2 AM every day:

0 2 * * * python3 sync_script.py

Just make sure you use the correct path to your python interpreter and script.

Common Pitfalls (Where I Usually Mess Up)

• Token Expiration: OAuth2 tokens expire. Your script must handle refreshing them. The library I used above does this automatically, but if you roll your own solution, this is a major gotcha.
• API Rate Limits: Don’t run your script every five minutes. Most APIs have generous daily limits, but hitting them is possible if your automation is too aggressive. Once a day is plenty.
• Scope and Permissions: Forgetting to enable the correct API (e.g., enabling Sheets but not Drive) or not sharing the Sheet with the service account email is the #1 cause of “permission denied” errors.
• Data Schema Changes: If you add a new column to your Google Sheet, you have to update your Python script to match. The script will fail if the number of columns doesn’t align.

Conclusion

And there you have it. A robust, automated pipeline to get your health data into a place where you can actually use it. You’ve now turned a manual, error-prone task into a reliable, “set it and forget it” system. From here, you can build Google Sheets charts, use Google Data Studio for advanced visualizations, or just enjoy having a clean, historical record of your progress. Happy automating!

Darian Vance

Lead Cloud Architect & DevOps Strategist

With over 12 years in system architecture and automation, Darian specializes in simplifying complex cloud infrastructures. An advocate for open-source solutions, he founded TechResolve to provide engineers with actionable, battle-tested troubleshooting guides and robust software alternatives.

🤖 Frequently Asked Questions