Skip to main content
Glama
garmin-givemydata

garmin-givemydata

by nrvim

garmin-givemydata (100% Working)

CI PyPI License: AGPL-3.0 Python 3.10+ MCP Platform GitHub stars

It's YOUR data. Take it back. One command. All your Garmin data. Local SQLite + FIT files. Export to CSV, JSON, GPX, TCX. AI-ready via MCP.

Garmin makes it nearly impossible for individuals to access their own health data programmatically. There is no public API. The official "developer program" is restricted to approved businesses only. And in March 2026, Garmin deployed aggressive Cloudflare protections that broke every single community library — garth (deprecated), python-garminconnect (broken auth), and all downstream tools like Home Assistant integrations.

You paid for the hardware. You generated the data with your body. You should be able to access it.

This project gets your data out of Garmin Connect and into a local SQLite database where you own it and AI can analyze it through an MCP server for Claude Code.

50 tables, 10+ years of history, 45 MCP tools for AI analysis. Your data stays on your machine.

The Problem

  • No public API: Garmin's Connect Developer Program requires a business application. Individual developers are denied.

  • garth is dead: The most popular auth library was deprecated on March 28, 2026 after Garmin changed their SSO flow.

  • Bot detection: Garmin deployed aggressive bot detection that blocks all known Python HTTP libraries. Every existing workaround stopped working.

  • python-garminconnect is broken: Depends on garth for auth. Issue #332 has 40+ comments from affected users.

  • Connect+ paywall: Garmin launched a $7/month subscription and is restricting third-party access to features that compete with it.

Nobody should buy Garmin products until they open their API to the people who paid for the hardware.

Related MCP server: GarminSynapse

Quick Start

Install

# macOS
brew install nrvim/tap/garmin-givemydata

# pip (Linux / Windows / macOS)
pip install garmin-givemydata

# or clone
git clone https://github.com/nrvim/garmin-givemydata.git
cd garmin-givemydata
bash setup.sh          # macOS / Linux
setup.bat              # Windows

Fetch your data

garmin-givemydata                    # fetches all historical data + FIT files

First run prompts for credentials, launches a headless browser, and fetches your full history (~30 min for 10 years). After that, daily syncs take seconds.

Connect AI

Add the MCP server to Claude Code, Claude Desktop, or any MCP client. The config depends on how you installed:

Claude Code (one-liner) — registers the server at user scope so it's available in every project:

# pip / brew install
claude mcp add -s user garmin -- garmin-mcp

# git clone
claude mcp add -s user garmin \
  -e GARMIN_DATA_DIR=/absolute/path/to/garmin-givemydata \
  -- /absolute/path/to/garmin-givemydata/venv/bin/python \
     /absolute/path/to/garmin-givemydata/run_mcp.py

Verify with claude mcp list. Skip the manual JSON below.

Homebrew or pip install — garmin-mcp is already in your PATH:

{
  "mcpServers": {
    "garmin": {
      "command": "garmin-mcp"
    }
  }
}

Git clone — use absolute paths to the venv and set GARMIN_DATA_DIR so the MCP server finds your database:

{
  "mcpServers": {
    "garmin": {
      "command": "/absolute/path/to/garmin-givemydata/venv/bin/python",
      "args": ["/absolute/path/to/garmin-givemydata/run_mcp.py"],
      "cwd": "/absolute/path/to/garmin-givemydata",
      "env": {
        "GARMIN_DATA_DIR": "/absolute/path/to/garmin-givemydata"
      }
    }
  }
}

Note: GARMIN_DATA_DIR tells the MCP server where garmin.db lives. Without it, the server falls back to ~/.garmin-givemydata/ which may not be where your data is if you cloned to a custom location.

Save this as:

  • Claude Code: .mcp.json in your project root, or ~/.claude/settings.json under mcpServers for global access

  • Claude Desktop: ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) or %APPDATA%\Claude\claude_desktop_config.json (Windows)

Restart your client and run /mcp to approve the server. Then ask:

"How was my sleep this week?"
"Am I overtraining? Check my HRV and recovery"
"Compare my fitness this month vs last month"
"Give me a full sports medicine health check"

Windows (git clone)

{
  "mcpServers": {
    "garmin": {
      "command": "C:\\Users\\jane\\code\\garmin-givemydata\\venv\\Scripts\\python.exe",
      "args": ["C:\\Users\\jane\\code\\garmin-givemydata\\run_mcp.py"],
      "cwd": "C:\\Users\\jane\\code\\garmin-givemydata",
      "env": {
        "GARMIN_DATA_DIR": "C:\\Users\\jane\\code\\garmin-givemydata"
      }
    }
  }
}

Other MCP clients (OpenClaw, Cline, Cursor)

Any client supporting MCP stdio transport can connect. For pip/brew: garmin-mcp. For git clone:

/path/to/garmin-givemydata/venv/bin/python /path/to/garmin-givemydata/run_mcp.py

Important: Paths must be absolute — relative paths will not work.

What You Get

  • ALL your data in one command — 50 tables, activities with splits/weather/HR zones/GPS trackpoints, original FIT files

  • 10+ years of history fetched automatically, smart incremental sync after that

  • 45 MCP tools for AI analysis — not just raw data, but tools with clinical context, anomaly detection, and professional training metrics

  • Export to anything — CSV, JSON, GPX, TCX from your local database

  • Your data stays local — nothing is sent anywhere

MCP Tools (45)

The MCP server gives AI assistants deep access to your health data. Every tool returns data + context — not just numbers, but trend direction, anomaly flags, clinical thresholds, and goal attainment.

Tool

What It Does

garmin_sync

Check data freshness and pull latest data from Garmin — always shows when the last sync happened. Use refresh=False to just check status

garmin_schema

Row counts for all 50 tables; pass tables="sleep,stress" for their columns

garmin_query

Run any read-only SELECT query (read-only enforced at the SQLite engine level)

Tool

What It Does

garmin_today

Complete snapshot: daily summary, last night's sleep, training readiness, HRV, fitness age, last activity

garmin_week_summary

Current week's totals vs goals: steps, intensity minutes, floors, calories

garmin_health_summary

Health overview for any date range with all metrics aggregated

Tool

What It Does

garmin_heart_rate

Resting HR with 7-day rolling average and anomaly detection (flags >5 bpm spikes)

garmin_hrv

HRV with baseline position, BALANCED/UNBALANCED streak, trend direction

garmin_sleep

Per-night breakdown with stages, deep/REM %, SpO2, stress, Garmin feedback

garmin_stress

Time-in-zone breakdown (hours in low/medium/high per day)

garmin_body_battery

Charge/drain patterns with wake values and sleep quality correlation

garmin_spo2

Clinical threshold flags (<95% warning, <80% sleep apnea recommendation)

garmin_respiration

Waking respiration with elevated-day flags (>20 breaths/min)

garmin_steps

Steps with goal attainment % and longest goal-met streak

garmin_floors

Floors climbed vs goal with ascent/descent breakdown

garmin_calories

Calorie breakdown: total, active, BMR, consumed

garmin_intensity_minutes

Weekly intensity vs WHO 150 min/week target, moderate vs vigorous

garmin_hydration

Fluid intake vs Garmin-calculated goal

garmin_blood_pressure

Readings with AHA guideline flags (>140/90 mmHg)

Tool

What It Does

garmin_training_load

CTL/ATL/TSB — professional periodization metrics with weekly volume and load by sport

garmin_recovery

Post-workout recovery signatures — RHR/HRV/body battery tracking after hard sessions, by sport

garmin_compare

Side-by-side period comparison — any two date ranges, all metrics, deltas + % changes

garmin_activities

List/filter activities by type and date — power, HR, training load, location

garmin_activity_detail

Deep-dive: splits, HR zones, weather, exercise sets in one call

garmin_activity_trackpoints

GPS trackpoints (~1Hz) — lat/lon, altitude, speed, HR, cadence, power, temperature in chronological order. Paginated. Use for elevation profiles, HR drift, GPS tracks, climb segmentation

garmin_race_predictions

5K/10K/half/marathon times with human-readable formatting and trend

garmin_endurance_score

Endurance score with classification tier and trend

garmin_hill_score

Hill score with endurance and strength sub-scores

garmin_vo2max

VO2max estimates from activities and dedicated tracking

garmin_training_status

Status history (Productive/Recovery/Detraining) with transition detection

garmin_fitness_age

Fitness age vs chronological age trajectory with gap analysis

garmin_records

All PRs with human-readable names (Fastest 5K, Longest Ride, etc.)

garmin_trends

Weekly/monthly trends for 17 metrics

Tool

What It Does

garmin_user_profile

Profile and settings from Garmin Connect

garmin_devices

Connected devices with type and last sync

garmin_gear

Equipment tracking (shoes, bikes, etc.)

garmin_badges

Earned achievements with dates

garmin_body_composition

Weight, BMI, body fat, muscle mass history

garmin_workouts

Workout library, training plans, scheduled workouts

garmin_goals

Active fitness goals

garmin_challenges

Garmin Connect challenges

garmin_health_snapshot

On-demand 2-minute health readings (HR, HRV, SpO2, stress)

garmin_daily_events

Daily events (stress spikes, body battery events)

garmin_activity_types

All activity type definitions

garmin_hr_zones

Heart rate zone definitions per sport

Usage

Fetch (from Garmin Connect)

garmin-givemydata                              # smart sync (all data + FIT files)
garmin-givemydata --full                       # force full historical re-fetch
garmin-givemydata --days 90                    # fetch last 90 days
garmin-givemydata --since 2025-01-01           # fetch from specific date
garmin-givemydata --profile health             # health metrics only
garmin-givemydata --profile activities         # activities + FIT files only
garmin-givemydata --profile sleep              # sleep data only
garmin-givemydata --no-files                   # skip FIT file downloads
garmin-givemydata                              # parses trackpoints for newly downloaded FIT files by default
garmin-givemydata --no-trackpoints             # skip trackpoint parsing during sync
garmin-givemydata --rebuild-trackpoints        # full rebuild: reparse all downloaded FIT files
garmin-givemydata --status                     # check database contents

FIT file download only

garmin-givemydata --fit-only --latest          # latest FIT file
garmin-givemydata --fit-only --date 2026-03-30 # specific date
garmin-givemydata --fit-only --days 7          # last 7 days
garmin-givemydata --fit-only                   # all FIT files

Export (from local database)

garmin-givemydata --export ./output            # CSV + JSON
garmin-givemydata --export-gpx ./gpx           # GPX (for Strava, Komoot)
garmin-givemydata --export-tcx ./tcx           # TCX (for TrainingPeaks)
garmin-givemydata --export-kml ./kml           # KML (for Google Earth)
garmin-givemydata --export-laps ./laps         # per-activity lap/split CSV

Format

Content

How

SQLite

Health + activities

Default — always created

FIT (ZIP)

Activities (lossless)

Default — downloaded automatically

CSV

Health + activities

--export ./dir

JSON

Health + activities

--export ./dir

GPX

Activities (GPS tracks)

--export-gpx ./dir

TCX

Activities (XML)

--export-tcx ./dir

KML

Activities (GPS tracks)

--export-kml ./dir

Lap CSV

Per-activity splits

--export-laps ./dir

Browser engine

Uses SeleniumBase UC mode (undetected Chrome) for Cloudflare bypass. Requires Google Chrome installed.

Engine

Headless

Cloudflare bypass

Session lifetime

SeleniumBase UC (Chrome)

Yes (via Xvfb on Linux)

Yes

Weeks on stable IP

Note: cf_clearance is bound to your IP address. If your IP changes, the session expires regardless of profile state. For unattended use, run on a machine with a stable egress IP.

Install method

Data location

Homebrew / pip

~/.garmin-givemydata/

Git clone

Current directory

Custom

Set GARMIN_DATA_DIR env var

garmin.db              # SQLite database (all health + activity data)
browser_profile/       # Browser session (persists ~1 year)
.env                   # Garmin credentials
fit/                   # Original FIT files (lossless)

Category

Data

Daily Health

Steps, calories, distance, floors, intensity minutes, active/sedentary time

Heart Rate

Resting HR, min/max HR, 7-day average

Stress

Average/max stress, stress duration by level, stress qualifier

Body Battery

Charged/drained values, highest/lowest, wake value, sleep value

Sleep

Duration by stage (deep/light/REM/awake), SpO2 during sleep, sleeping HR, respiration, sleep score

SpO2

Average, lowest, latest readings

Respiration

Waking average, highest, lowest

HRV

Weekly average, last night, baseline ranges, status

Training Readiness

Score, level, factor breakdowns (HRV, sleep, stress, recovery, load ratio)

Endurance Score

Overall score, classification tier, VO2max precise value

Hill Score

Overall score, endurance sub-score, strength sub-score

Race Predictions

Predicted times for 5K, 10K, half marathon, marathon

Activities

45+ fields per activity: duration, distance, HR, power, cadence, elevation, TSS, training effect, VO2max, GPS, temperature, laps

Activity Splits

Per-km/mile splits with pace, HR, elevation, cadence

Activity HR Zones

Time spent in each HR zone per activity

Activity Weather

Temperature, humidity, wind speed/direction during activity

Activity Exercise Sets

Strength training: exercise name, reps, weight, duration per set

Activity Trackpoints

GPS samples at ~1Hz: lat/lon, altitude, distance, speed, HR, cadence, power, temperature (parsed from FIT files)

Weight

Weight, BMI, body fat, body water, bone mass, muscle mass

VO2max

Running and cycling VO2max trend over time

Blood Pressure

Systolic, diastolic, pulse

Calories

Total, active, BMR, consumed, remaining

Nutrition

Daily consumed calories/protein/fat/carbs, plus a per-food log: every logged food with servings, time, and full macro/micronutrient breakdown (fiber, sugars, fats, sodium, potassium, cholesterol, calcium, iron, vitamins A/C/D)

Fitness Age

Chronological age vs fitness age

Personal Records

All PRs across all activity types

Earned Badges

All badges earned with date and category

Devices

All registered Garmin devices and sensors

Gear

Shoes, bikes, etc. with brand, model, usage tracking

Training Status

Daily and weekly training status (productive, recovery, etc.)

Health Status

Overall daily health status assessment

Hydration

Daily goal and intake in ml

Architecture

garmin-givemydata/
├── garmin_givemydata.py       # Main entry: smart sync (full or incremental)
├── garmin_client/              # SeleniumBase-based Garmin Connect client
│   ├── client.py               #   GarminClient (login, fetch, export)
│   └── endpoints.py            #   API endpoint definitions
├── garmin_mcp/                 # MCP server + database layer
│   ├── db.py                   #   SQLite schema (50 tables), upsert helpers
│   ├── server.py               #   FastMCP server with 45 tools
│   ├── export.py               #   CSV, JSON, GPX, TCX export
│   ├── import_json.py          #   JSON → SQLite bulk import
│   └── sync.py                 #   Incremental sync engine
├── run_mcp.py                  # MCP server entry point
├── garmin.db                   # Your health data (SQLite, gitignored)
├── fit/                        # Your activity files (FIT/ZIP, gitignored)
├── browser_profile/            # Browser session (gitignored)
└── pyproject.toml

Data flow:

Garmin Connect ──→ SQLite (health + activity metrics)
                └─→ fit/ (original FIT files, lossless)

SQLite ──→ MCP server (AI queries via 45 tools)
       ├─→ CSV/JSON (--export)
       └─→ GPX/TCX (--export-gpx, --export-tcx)

Platform Support

Platform

Status

Notes

macOS

Tested

Primary development platform

Linux (Ubuntu/Debian/Fedora)

Supported

Needs Chrome + optional xvfb for headless SSH

Windows 10/11

Supported

Use PowerShell or Command Prompt

WSL2

Supported

Works headless with Xvfb

brew install python@3.12
cd garmin-givemydata
python3.12 -m venv venv
source venv/bin/activate
pip install -r requirements.txt
# Chrome must be installed (https://www.google.com/chrome/)
cp .env.example .env
sudo apt update && sudo apt install python3.12 python3.12-venv
cd garmin-givemydata
python3.12 -m venv venv
source venv/bin/activate
pip install -r requirements.txt
# Chrome must be installed (https://www.google.com/chrome/)
cp .env.example .env
sudo dnf install python3.12
cd garmin-givemydata
python3.12 -m venv venv
source venv/bin/activate
pip install -r requirements.txt
# Chrome must be installed (https://www.google.com/chrome/)
cp .env.example .env

Install Python 3.10+ from python.org — check "Add to PATH".

cd garmin-givemydata
python -m venv venv
venv\Scripts\Activate.ps1
pip install -r requirements.txt
# Chrome must be installed (https://www.google.com/chrome/)
copy .env.example .env

If PowerShell blocks the activate script: Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser

Troubleshooting

"Login failed": Delete the browser profile and run again. For pip/brew: rm -rf ~/.garmin-givemydata/browser_profile. For git clone: rm -rf browser_profile/.

Script crashed: Don't close the Chrome window manually. The tool handles shutdown — killing Chrome mid-run corrupts the profile. Run again (stale locks are auto-cleaned).

"Python not found": Make sure Python 3.10+ is on your PATH. macOS: brew install python@3.12. Ubuntu: sudo apt install python3.12 python3.12-venv.

ensurepip is not available / venv creation fails: Your system Python is missing the venv module. Install the matching package: sudo apt install python3.X-venv (replace X with your minor version — python3 --version to check). On Ubuntu with Python 3.14, that's python3.14-venv. The setup.sh script auto-detects Python but can't auto-install the venv package.

403 or session errors: Session expired (often from IP change — cf_clearance is IP-bound). Delete the browser profile and re-login.

Chrome doesn't open (Linux/SSH): Install Xvfb: sudo apt install xvfb. The tool auto-spawns Xvfb at 1920x1080 when no display is available, or use xvfb-run -a garmin-givemydata.

Session rot over SSH: Run under systemd-run --user --scope or tmux/screen so SSH disconnect doesn't SIGHUP the process. The tool installs signal handlers but a detached session is more reliable.

MCP server "failed to connect": Paths in .mcp.json must be absolute. Test: <path>/venv/bin/python <path>/run_mcp.py

Empty data for some metrics: Training readiness, HRV, body battery, endurance score, hill score, and race predictions require compatible devices (Fenix 7+, Forerunner 265+, Venu 3+, etc.).

Windows: "execution of scripts is disabled": Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser

Company

Open API for Individuals?

Real-time Access?

Data Portability Grade

Oura

Yes — free, any ring owner

Yes, REST API

A+

WHOOP

Yes — free, any member

Yes, API + webhooks

A+

Fitbit

Yes — personal app type

Yes, REST API

A

Apple Health

Yes — HealthKit on-device

Yes, on-device

A-

Polar

Yes — any developer

Partial

B+

Garmin

No — business-only

No

D

COROS

No — partner-only

No

D+

Samsung

No — deprecated SDK

On-device only

D

Amazfit/Zepp

No

No

F

Contributing

  • New endpoints: Garmin has hundreds of internal APIs. Discover new ones via browser dev tools and add them to endpoints.py.

  • More MCP tools: The server has 45 tools including CTL/ATL/TSB, recovery signatures, and period comparison. Ideas: injury risk prediction, sleep optimization, race readiness scoring, overtraining detection.

  • MCP client integrations: Test with OpenClaw, Cline, Continue, Cursor, or other clients.

  • Other platforms: ARM (Raspberry Pi), Docker, etc.

  • Data visualization: Dashboards, charts, reports from SQLite.

  • Export formats: Parquet, or other formats for pandas, R.

  • Other wearables: The architecture (browser auth + SQLite + MCP) could work for COROS, Samsung, Amazfit/Zepp.

  • Testing: Tests, CI, more platform support.

Open an issue or submit a PR.

Support This Project

  • Star this repository — helps others discover the project

  • Report issues — improve stability and compatibility

  • Spread the word — share with other Garmin users

  • Contribute code — new endpoints, MCP tools, export formats, bug fixes

  • File a GDPR/CCPA request with Garmin — the more users who formally request data portability, the harder it is to ignore

Acknowledgments

  • garth by @matin — 350k+ monthly PyPI downloads before deprecation. The auth library that powered the Garmin Python ecosystem.

  • python-garminconnect by @cyberjunky — 2,000+ stars, 127+ API methods. The endpoint catalog was informed by their work.

  • GarminDB by @tcgoetz — 3,000+ stars. Pioneered SQLite-first Garmin data storage.

  • garmin-connect-export — Reliable activity export (GPX, TCX, FIT, JSON).

  • garmin-data-export — Garmin data into LLM-readable text files.

  • garmy — AI-first Garmin data access with MCP support.

EU/EEA — GDPR

Article 20 — Right to Data Portability grants the right to receive personal data in a "structured, commonly used and machine-readable format." This covers raw sensor data (heart rate, sleep, steps, SpO2). Derived metrics (training readiness, fitness age) are covered under Article 15 — Right of Access.

United States — CCPA

Section 1798.100(d) requires businesses to provide personal information in a "readily useable format that allows the consumer to transmit this information from one entity to another entity without hindrance."

EU Data Act (Since September 2025)

Article 3 explicitly requires IoT manufacturers to make data available "without undue delay, free of charge, and, where applicable, continuously and in real-time." A Garmin watch is an IoT device. The data it generates belongs to the user.

If Garmin provided an open API, this tool would not need to exist.

Disclaimer

This tool is unofficial and not affiliated with Garmin. It accesses Garmin Connect using your own credentials to retrieve your own data. Use may violate Garmin's Terms of Service. You assume all risk and responsibility. See the full disclaimer for details.

License

AGPL-3.0 — Free to use, modify, and distribute. If you build a service using this code, you must keep it open source.

Available Tools

48 tools
garmin_activitiesB

List activities with optional filters by type and date range.

Returns key fields: name, type, date, duration_min, distance_km, calories, avg_hr, elevation, power, training_load, location.

Inputs: limit, end_date, start_date, activity_type. Returns: result

garmin_activity_detailA

Deep-dive into a single activity.

Pass activity_id, or set last=True for the most recent activity. Returns the activity summary plus splits, HR zones, weather, and exercise sets (if available).

Inputs: last, activity_id. Returns: result

garmin_activity_trackpointsA

GPS trackpoints for an activity — lat/lon, altitude, distance, speed, HR, cadence, power, temperature, in chronological order.

Trackpoints are sampled ~1/second, so a 1-hour activity has ~3600 points. Pass limit and offset to page through them; the response includes total_count so callers know the full size.

Best for: elevation profile, HR drift over time, GPS track inspection, pacing analysis, climb segmentation. For aggregate stats (splits, zones, weather), prefer garmin_activity_detail — much smaller output.

Inputs: activity_id (required), limit, offset. Returns: result

garmin_activity_typesB

All Garmin activity type definitions with IDs and parent categories.

Inputs: no named parameters. Returns: result

garmin_badgesB

Earned badges and achievements with dates.

Tracks milestones like distance PRs, consistency streaks, and special event completions. Shows progression over time.

Inputs: no named parameters. Returns: result

garmin_blood_pressureB

Blood pressure readings (systolic/diastolic/pulse) if tracked.

Requires a compatible Garmin blood pressure monitor. Flags readings outside normal ranges (>140/90 mmHg per AHA guidelines).

Inputs: days. Returns: result

garmin_body_batteryB

Body battery with charge efficiency and drain analysis.

Returns per-day values enriched with: how much you charged overnight vs how much you drained during the day, wake-up charge level, and whether sleep quality (deep sleep) correlated with better charging.

Inputs: days. Returns: result

garmin_body_compositionB

Weight, BMI, and body composition history with trend analysis.

Inputs: no named parameters. Returns: result

garmin_caloriesB

Daily calorie breakdown: total, active, BMR, and consumed (if logged).

Combines daily_summary calorie data with the dedicated calories table for a complete energy picture.

Inputs: days. Returns: result

garmin_challengesB

Garmin Connect challenges (active and completed).

Inputs: no named parameters. Returns: result

garmin_compareB

Side-by-side comparison of two date ranges across all health metrics.

Useful for week-over-week, month-over-month, or year-over-year analysis. Returns deltas and percentage changes for every metric.

Inputs: period1_end (required), period2_end (required), period1_start (required), period2_start (required). Returns: result

garmin_daily_eventsC

Daily events detected by your Garmin (stress spikes, body battery events, etc).

Inputs: days. Returns: result

garmin_devicesC

Connected Garmin devices with type and last sync time.

Inputs: no named parameters. Returns: result

garmin_endurance_scoreC

Endurance score and VO2max with classification and trend.

Inputs: days. Returns: result

garmin_fitness_ageA

Fitness age vs chronological age trajectory over time.

Shows the gap between biological fitness and real age, aggregated by week or month. A widening gap means you're getting fitter relative to your age; a narrowing gap means fitness is declining.

Inputs: period. Returns: result

garmin_floorsC

Daily floors climbed vs goal, with ascent/descent breakdown.

Inputs: days. Returns: result

garmin_gearB

Tracked gear/equipment (shoes, bikes, etc) with usage stats.

Inputs: no named parameters. Returns: result

garmin_goalsC

Active fitness goals and their current progress.

Inputs: no named parameters. Returns: result

garmin_health_snapshotA

On-demand health snapshot readings (2-minute wrist measurements).

These are manual measurements taken via the watch's Health Snapshot feature, capturing HR, HRV, SpO2, stress, and respiration simultaneously.

Inputs: no named parameters. Returns: result

garmin_health_summaryB

Health overview for a date range.

If start_date/end_date are omitted the most recent days days are used. Returns averages for steps, HR, stress, body battery, SpO2, respiration, calories (daily_summary), sleep metrics (sleep table), and training readiness score.

Inputs: days, end_date, start_date. Returns: result

garmin_heart_rateB

Resting heart rate with trend analysis and anomaly detection.

Returns daily RHR plus a rolling 7-day average. Flags days where RHR jumped >5 bpm above your 7-day average (a sign of illness, overtraining, or poor recovery per sports science literature).

Inputs: days. Returns: result

garmin_hill_scoreC

Hill score with endurance and strength sub-scores.

Inputs: days. Returns: result

garmin_hrvB

HRV (Heart Rate Variability) with clinical context.

Unlike raw HRV numbers, this returns your personal baseline range, how many consecutive days you've been BALANCED vs UNBALANCED, trend direction, and whether current values are above/below baseline.

Inputs: days. Returns: result

garmin_hr_zonesB

Heart rate zone definitions configured in your Garmin profile.

Inputs: no named parameters. Returns: result

garmin_hydrationB

Daily hydration intake vs goals.

Tracks fluid intake, compares against Garmin's calculated goal (which factors in activity, weather, and body weight), and flags days with significant under-hydration.

Inputs: days. Returns: result

garmin_intensity_minutesB

Weekly intensity minutes vs the WHO-recommended 150 min/week.

Breaks down moderate vs vigorous minutes (vigorous counts double per WHO guidelines). Shows weekly totals and goal attainment.

Inputs: days. Returns: result

garmin_lactate_thresholdA

Lactate threshold pace and heart rate by sport.

The lactate threshold is the highest intensity you can sustain aerobically. Used to set training zones and pace targets for races.

Inputs: no named parameters. Returns: result

garmin_load_focusC

Training load distribution across aerobic and anaerobic zones.

Shows how your training load is split between low aerobic, high aerobic, and anaerobic zones, plus a focus_status indicating whether your training distribution is optimal.

Inputs: days. Returns: result

garmin_queryB

Run a read-only SELECT query against the Garmin database.

The database is opened in SQLite read-only mode at the engine level, so writes, ATTACH, and schema changes are impossible regardless of the SQL content. Results are capped at limit rows (default 1000).

Inputs: sql (required), limit. Returns: result

garmin_race_predictionsB

Predicted race finish times (5K, 10K, half marathon, marathon).

Shows daily predictions with human-readable times and trend direction. A rising prediction time means declining fitness; falling means improving.

Inputs: days. Returns: result

garmin_recordsB

All personal records (PRs) with activity details and dates.

Inputs: no named parameters. Returns: result

garmin_recoveryA

Analyze how your body recovers after hard training sessions.

For each activity with training_load > 80, shows RHR and HRV for the following days. Reveals your personal recovery curve and identifies which sports/intensities hit you hardest.

This is unique — no other Garmin MCP computes recovery signatures.

Inputs: days_after. Returns: result

garmin_respirationC

Waking respiration rate with min/max range.

Elevated respiration at rest can indicate illness, stress, or cardiovascular strain. Normal adult range is 12-20 breaths/min.

Inputs: days. Returns: result

garmin_schemaA

Show table columns and row counts.

Called without tables, returns a compact index: row count per non-empty table, plus the names of the empty ones — no column lists. Pass a comma-separated list of table names (e.g. "sleep,stress") to get the columns of just those tables.

Inputs: tables. Returns: result

garmin_sleepB

Per-night sleep breakdown with stages, SpO2, stress, and Garmin feedback.

Returns each night individually (not averages) for pattern analysis.

Inputs: days, start_date. Returns: result

garmin_spo2B

Blood oxygen (SpO2) with clinical threshold analysis.

Flags days where average SpO2 dropped below 95% (clinical concern) or nocturnal lows dropped below 80% (possible sleep apnea indicator). Includes both daily_summary and dedicated spo2 table data.

Inputs: days. Returns: result

garmin_stepsB

Daily step count with goal attainment and streaks.

Shows steps per day, percentage of goal, and identifies the longest consecutive streak of meeting your step goal.

Inputs: days. Returns: result

garmin_stressB

Stress with time-in-zone breakdown (low/medium/high).

Goes beyond the average — shows how many hours per day you spent in each stress zone, plus max stress spikes and the stress qualifier.

Inputs: days. Returns: result

garmin_syncA

Sync the latest data from Garmin Connect.

The sync runs in the background (~2 minutes). The first call returns immediately with status "started"; follow up with garmin_sync(refresh=False) after ~2 minutes to see the final result. This avoids MCP client timeouts (Claude Desktop ~60s) that previously made synchronous sync unusable.

Set refresh=False to just check the current state and last sync result without triggering a new sync.

Use this when:

  • You just finished a run/ride and want to see the new data

  • You want to make sure today's health data is loaded

  • The data looks outdated

Inputs: refresh. Returns: result

garmin_todayA

Complete snapshot of today's health: daily summary, last night's sleep, training readiness, HRV status, body battery, and most recent activity. Ideal as conversation context — call this first to ground any health question.

Inputs: no named parameters. Returns: result

garmin_training_loadB

Compute professional training periodization metrics from activity history.

Returns:

  • CTL (Chronic Training Load, 42-day EWMA) — long-term fitness proxy

  • ATL (Acute Training Load, 7-day EWMA) — short-term fatigue

  • TSB (Training Stress Balance = CTL - ATL) — form / readiness

  • Weekly volume summary (hours, km, sessions, load)

  • Training load distribution by sport

Inputs: no named parameters. Returns: result

garmin_training_statusB

Training status history (Productive, Recovery, Detraining, Unproductive, etc).

Shows how Garmin classified your training state each day, with a breakdown of how many days you spent in each status and when transitions happened. Useful for spotting detraining before it deepens.

Inputs: days. Returns: result

garmin_user_profileC

User profile and settings stored in Garmin Connect.

Inputs: no named parameters. Returns: result

garmin_vo2maxB

VO2max estimates from activities and the dedicated vo2max table.

Pulls from both the activity-level VO2max estimates and the standalone vo2max tracking table.

Inputs: no named parameters. Returns: result

garmin_week_summaryA

Current week's health totals vs goals, with daily breakdown.

Shows steps, intensity minutes, floors, and calories for each day of the current week, plus totals vs weekly targets.

Inputs: no named parameters. Returns: result

garmin_wellness_activityB

Wellness activity sessions detected by Garmin (yoga, breathwork, etc).

These are non-sport wellness sessions tracked separately from regular activities, including start/end times and activity type.

Inputs: days. Returns: result

garmin_workoutsA

Workout library and upcoming schedule.

Returns saved workouts (training plans, custom workouts) and any scheduled workout dates. Useful for understanding planned vs executed training.

Inputs: no named parameters. Returns: result

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    B3.1/5.0

    Scored across 48 tools

    Disambiguation3/5

    Many tools have clearly distinct purposes, but significant overlap exists among metric-specific tools (e.g., garmin_heart_rate vs garmin_hrv vs garmin_hr_zones; garmin_body_battery vs garmin_stress vs garmin_respiration). The presence of catch-all tools like garmin_query and garmin_health_summary alongside specialized ones increases ambiguity about when to use which.

    Naming Consistency5/5

    All tools follow a consistent snake_case pattern with the 'garmin_' prefix, making names predictable and easy to recognize as a cohesive set.

    Tool Count2/5

    48 tools is excessive for a personal health data server, likely overwhelming an agent and causing selection confusion. While the domain is broad, the surface is bloated with many highly specific metrics that could be consolidated.

    Completeness4/5

    The toolset covers nearly every Garmin Connect data type: activities, sleep, stress, body battery, training metrics, nutrition, gear, and more. Some gaps remain (e.g., no explicit write/update operations, but those may be out of scope for a read-only client), but overall coverage is extensive.

    Maintenance

    ActivityMaintained
    ResponsivenessUsually handled

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      D
      maintenance
      A local MCP server that exposes your Garmin Connect data—sleep, HRV, training readiness, workouts, and more—to any MCP-compatible AI assistant. Runs entirely on your machine and keeps your Garmin credentials private.
      MIT
    • F
      license
      Not graded
      quality
      B
      maintenance
      Enables AI assistants to retrieve and analyze Garmin Connect health data, including daily summaries, sleep, HRV, workouts, and raw FIT files, while also supporting SQL queries on the underlying database.
      10
      -
    • A
      license
      A
      quality
      A
      maintenance
      Archives Garmin Connect health data locally (steps, HR, sleep, body battery) as JSON, no cloud, and also pulls context data (weather, pollen, air quality). Built-in MCP server (with SQLite cache) exposes the archive for querying via LLM tool calls.
      11
      27
      GPL 3.0
    • A
      license
      Not graded
      quality
      B
      maintenance
      Syncs your own Garmin Personal API data into a local SQLite archive and lets any MCP-capable AI assistant query sleep, HRV, stress, body battery, training and activity trends through natural language, with optional interactive charts. Everything runs locally with your own API key, so private health data stays on your machine.
      76 PyPI
      1
      Apache 2.0