garmin-givemydata
Query your own Garmin data locally through AI — this MCP server syncs Garmin Connect data into SQLite and exposes ~48 read-only tools for health, sleep, training, and activity analysis.
Sync & inspect data: trigger background syncs (
garmin_sync), check freshness, view per-table row counts/columns (garmin_schema), and run arbitrary read-only SQL (garmin_query)Daily wellness snapshots: today's full picture (
garmin_today), weekly goal progress (garmin_week_summary), and date-range aggregates (garmin_health_summary)Health metrics with clinical context: heart rate + anomaly flags, HRV baseline/balance, sleep stages per night, stress zones, body battery, SpO2 thresholds, respiration, steps, floors, calories, intensity minutes (WHO 150 min), hydration, blood pressure (AHA flags), body composition/weight
Training & performance: CTL/ATL/TSB periodization (
garmin_training_load), post-workout recovery signatures, training status history, load focus (aerobic/anaerobic), lactate threshold, VO2max, endurance/hill scores, race predictions, fitness age, personal records, trends for 17 metricsActivity deep dives: list/filter activities, per-activity detail (splits, HR zones, weather, exercise sets), and ~1Hz GPS trackpoints (lat/lon, altitude, speed, HR, power) for elevation, HR-drift, and pacing analysis
Comparisons & analysis: side-by-side date-range comparison (
garmin_compare), recovery curves after hard sessions, and week/month trend aggregationProfile & ecosystem: user profile, devices, gear (shoes/bikes), workouts/plans, goals, challenges, badges, activity types, HR zones, health snapshots, daily events, and wellness sessions
Safety: all queries are read-only, enforced at the SQLite engine level; data stays local on your machine
Provides tools to fetch and analyze all Garmin Connect health and fitness data, including activities, sleep, HRV, stress, training load, and more through a local SQLite database.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@garmin-givemydata show my sleep score for last night"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
garmin-givemydata (100% Working)
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 # WindowsFetch your data
garmin-givemydata # fetches all historical data + FIT filesFirst 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.pyVerify 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_DIRtells the MCP server wheregarmin.dblives. 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.jsonin your project root, or~/.claude/settings.jsonundermcpServersfor global accessClaude 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.pyImportant: 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 |
| Check data freshness and pull latest data from Garmin — always shows when the last sync happened. Use |
| Row counts for all 50 tables; pass |
| Run any read-only SELECT query (read-only enforced at the SQLite engine level) |
Tool | What It Does |
| Complete snapshot: daily summary, last night's sleep, training readiness, HRV, fitness age, last activity |
| Current week's totals vs goals: steps, intensity minutes, floors, calories |
| Health overview for any date range with all metrics aggregated |
Tool | What It Does |
| Resting HR with 7-day rolling average and anomaly detection (flags >5 bpm spikes) |
| HRV with baseline position, BALANCED/UNBALANCED streak, trend direction |
| Per-night breakdown with stages, deep/REM %, SpO2, stress, Garmin feedback |
| Time-in-zone breakdown (hours in low/medium/high per day) |
| Charge/drain patterns with wake values and sleep quality correlation |
| Clinical threshold flags (<95% warning, <80% sleep apnea recommendation) |
| Waking respiration with elevated-day flags (>20 breaths/min) |
| Steps with goal attainment % and longest goal-met streak |
| Floors climbed vs goal with ascent/descent breakdown |
| Calorie breakdown: total, active, BMR, consumed |
| Weekly intensity vs WHO 150 min/week target, moderate vs vigorous |
| Fluid intake vs Garmin-calculated goal |
| Readings with AHA guideline flags (>140/90 mmHg) |
Tool | What It Does |
| CTL/ATL/TSB — professional periodization metrics with weekly volume and load by sport |
| Post-workout recovery signatures — RHR/HRV/body battery tracking after hard sessions, by sport |
| Side-by-side period comparison — any two date ranges, all metrics, deltas + % changes |
| List/filter activities by type and date — power, HR, training load, location |
| Deep-dive: splits, HR zones, weather, exercise sets in one call |
| 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 |
| 5K/10K/half/marathon times with human-readable formatting and trend |
| Endurance score with classification tier and trend |
| Hill score with endurance and strength sub-scores |
| VO2max estimates from activities and dedicated tracking |
| Status history (Productive/Recovery/Detraining) with transition detection |
| Fitness age vs chronological age trajectory with gap analysis |
| All PRs with human-readable names (Fastest 5K, Longest Ride, etc.) |
| Weekly/monthly trends for 17 metrics |
Tool | What It Does |
| Profile and settings from Garmin Connect |
| Connected devices with type and last sync |
| Equipment tracking (shoes, bikes, etc.) |
| Earned achievements with dates |
| Weight, BMI, body fat, muscle mass history |
| Workout library, training plans, scheduled workouts |
| Active fitness goals |
| Garmin Connect challenges |
| On-demand 2-minute health readings (HR, HRV, SpO2, stress) |
| Daily events (stress spikes, body battery events) |
| All activity type definitions |
| 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 contentsFIT 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 filesExport (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 CSVFormat | Content | How |
SQLite | Health + activities | Default — always created |
FIT (ZIP) | Activities (lossless) | Default — downloaded automatically |
CSV | Health + activities |
|
JSON | Health + activities |
|
GPX | Activities (GPS tracks) |
|
TCX | Activities (XML) |
|
KML | Activities (GPS tracks) |
|
Lap CSV | Per-activity splits |
|
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 |
|
Git clone | Current directory |
Custom | Set |
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.tomlData 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 |
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 .envsudo 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 .envsudo 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 .envInstall 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 .envIf 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 |
Yes — free, any ring owner | Yes, REST API | A+ | |
Yes — free, any member | Yes, API + webhooks | A+ | |
Yes — personal app type | Yes, REST API | A | |
Yes — HealthKit on-device | Yes, on-device | A- | |
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 toolsgarmin_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_trendsB
Return trend data for a metric aggregated by week or month.
Supported metrics: resting_hr, stress, steps, sleep_hours, body_battery, spo2, training_readiness, floors, calories, active_minutes, respiration, weight, hrv, endurance_score, hill_score, race_5k, race_10k. period: 'week' or 'month'.
Inputs: metric (required), period. 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
Scored across 48 tools
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.
All tools follow a consistent snake_case pattern with the 'garmin_' prefix, making names predictable and easy to recognize as a cohesive set.
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.
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
Related MCP Connectors
Garmin watch data for AI assistants: activities, sleep, HRV, recovery. Never writes to Garmin.
Garmin data in Claude: 135 tools — activities, sleep, HRV, training, workouts. Free, open source.
Explore Garmin activity and health data with your AI assistant.
Your Garmin, Oura, WHOOP, Hevy and 35 more fitness apps, queryable from your own AI.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceA 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
- FlicenseNot gradedqualityBmaintenanceEnables 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-
- AlicenseAqualityAmaintenanceArchives 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.1127GPL 3.0
- AlicenseNot gradedqualityBmaintenanceSyncs 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 PyPI1Apache 2.0