Garmin MCP Server: Connect Garmin to Claude and ChatGPT
Give Claude or ChatGPT live access to your Garmin activities, sleep, HRV and stress data through MCP, so it answers from your real numbers, not a screenshot.
You ask Claude about your training and it asks you for a screenshot
You finished a 90 minute ride with a weird heart rate profile, and you want a second opinion. So you open Claude, describe the session from memory, and get back a confident, articulate answer about a ride it has never seen. It does not know your heart rate drifted 8 BPM in the last 30 minutes. It does not know you slept 5 hours 40 the night before. It does not know this is the fourth hard session in nine days.
The model is not the problem. The model is genuinely good at this kind of reasoning. It is just blind, and you cannot type your way out of blindness. The data that would make the answer good is twelve weeks of activities, sleep stages, HRV readings and daily stress scores, which is exactly the volume of data that is impossible to hand-feed into a chat window.
An MCP server fixes this at the root. Instead of you describing the ride, the model fetches it.
What MCP actually is
The Model Context Protocol is an open standard for letting AI assistants call external tools. It was published by Anthropic in late 2024 and has since been adopted well beyond Claude: ChatGPT, Cursor and Perplexity all speak it. The protocol itself is boring in the good way. A server advertises a list of tools, each with a name and a schema. The model decides when to call them. The results come back as structured data the model can reason over.
For training data, that shape is exactly right. You do not want the model to have a static dump of your history sitting in its context window, going stale the moment you finish your next run. You want it to ask a question when it needs an answer, the same way you would open Garmin Connect and click into a specific week.
So "Garmin MCP server" means a server that exposes your Garmin Connect history as tools. Ask "how did my last four weeks compare to the four before that?" and the model calls a tool that returns activities for both windows, then does the comparison against real numbers.
What the Garmin connector exposes
The AthleteData MCP server registers 18 Garmin-specific tools when Garmin is connected. They fall into four groups.
Activities. garmin_get_activities for a window of sessions, garmin_get_activity and garmin_get_activity_details for one session in depth, garmin_list_activity_files and garmin_get_activity_file when the model needs the raw FIT file to look at per-second streams rather than summary fields.
Sleep and recovery. garmin_get_sleep returns stages and duration. garmin_get_hrv returns overnight heart rate variability, garmin_get_heart_rate the underlying beat data. garmin_get_stress returns Garmin's all-day stress score, and garmin_get_respiration, garmin_get_pulse_ox and garmin_get_skin_temps cover the sensors most people never look at but which matter when something is going wrong.
Body and daily context. garmin_get_body_composition for weight and body fat if you use a compatible scale, garmin_get_daily_summaries for steps, calories and intensity minutes, garmin_get_user_metrics for VO2max and fitness age, garmin_get_health_snapshot and garmin_get_move_iq for the rest.
Writing back. garmin_push sends a structured workout to your watch. That is the one tool in the set that changes something rather than reading it, and it is what turns a conversation into a session you actually ride. There is more on how that works in the guide to pushing workouts to a Garmin watch.
Alongside those, the connector registers derived analytics that are not Garmin fields at all but computed across everything you have connected: get_pmc_status for fitness and fatigue balance, get_power_curve and get_pace_curve for best efforts by duration, get_training_trends, get_load_balance, get_injury_risk and get_readiness_today. These are the ones that tend to change how the conversation goes, because they answer questions Garmin Connect does not have a screen for.
Why this beats the alternatives
There are three other ways people try to get Garmin data in front of a model, and each fails in a specific way.
Screenshots. The model reads them imperfectly, cannot follow up, and cannot compare this week to a week in April. You are also implicitly choosing which data matters before the model has looked at any of it, which defeats the point of asking.
CSV exports. These work exactly once. The moment you train again the file is stale, and re-exporting before every conversation is enough friction that nobody does it twice.
Self-hosted scrapers. Search for "garmin mcp" and you will find open-source projects that log into Garmin Connect with your account password and scrape the web interface. They work until Garmin changes a page, which happens without notice, and they require you to keep a local process running. Handing your Garmin password to a script is also a meaningfully different security posture from an OAuth grant you can revoke with one click.
The hosted route uses Garmin's official Health and Activity APIs through an OAuth grant. Nothing runs on your machine, nothing breaks when Garmin ships a redesign, and revoking access is a button on the Garmin integration page rather than a password change.
Setting it up
The whole flow is about five minutes, and most of it is waiting for Garmin's OAuth screen.
1. Connect Garmin. Sign in at athletedata.health, open the integrations page, and click Connect on Garmin. You will land on Garmin's own consent screen, which lists the permission scopes being requested. Approve, and you come back with the connection live.
2. Wait for the initial pull. Garmin's Health API enforces a hard backfill floor of roughly 30 days from the moment you authorize. Requests for windows starting earlier than that are refused at the API level, which is a Garmin constraint rather than a platform one. So your first sync brings in about a month, and the history grows forward from there. If you want years rather than weeks, request an Export Your Data archive from Garmin, upload the ZIP, and it is ingested through the same pipeline. Records merge on activity ID, so a session that exists in both the live sync and the archive lands once.
3. Copy your MCP URL. In the dashboard, use the Copy MCP URL button. It produces a URL of the form https://mcp.athletedata.health/mcp?apiKey=sk_soma_.... That key is yours alone and is revocable from the same page.
4. Add it to your AI client. In Claude, open Settings, then Connectors, then Add custom connector. Name it athletedata, paste the URL, and click Add. The connector should show as Connected. ChatGPT, Cursor and Perplexity each have an equivalent connector panel, and there are step-by-step pages for all four in the MCP setup section.
5. Ask it something specific. Open a new chat and ask a question that requires data you have never typed, for example "what was my training load over the last four weeks, and how does my HRV trend compare?" You will see the tool calls fire before the answer comes back. That is the confirmation that it is reading rather than guessing.
What changes about the conversation
The interesting shift is not that the model can now recite your data. It is that you stop pre-filtering.
When you have to type your context, you decide in advance what is relevant. You mention the hard session because you think the hard session is the story. You do not mention that your sleep has been 40 minutes short for nine straight days, because you did not connect the two. With tools available, the model can go looking. Ask "why did today's easy run feel awful?" and a well-posed answer pulls yesterday's session, last night's sleep, your HRV trend and your fitness-fatigue balance before saying anything.
This is also where the derived tools earn their place. Garmin gives you a Training Status label. It does not give you a chronic training load number you can argue with, and it will not tell you that your 42-day ramp rate is steeper than the two blocks that preceded your last two injuries. The fitness and fatigue chart guide covers what those curves mean and how to read them; the point here is that a model with tool access can compute the comparison rather than describing the concept.
A worked example, because the difference is concrete. Ask a model without tools "should I do tomorrow's threshold session?" and you get a paragraph about listening to your body. Ask a model with tools and it calls get_readiness_today, garmin_get_hrv and get_pmc_status, notices your HRV has been below baseline for four days while your acute load has climbed, and tells you the specific thing: move the session to Thursday, keep tomorrow at 60 minutes easy.
The limits worth knowing about
Strava is not available over MCP. Strava's API terms do not permit serving Strava data to third-party AI platforms and tools, so it is excluded from the connector. Every other source works. If Garmin is your primary device this changes nothing, since your activities are already arriving from Garmin directly.
The 30-day floor is real. It catches people out because the connection looks healthy and simply has no April data in it. The Export Your Data path exists precisely for this and is worth doing once, on day one, rather than discovering the gap three months later when you want a year-over-year comparison.
Tool access is not a coach. The connector answers questions you ask. It does not notice that your resting heart rate has been climbing and message you about it, because nothing is running between your conversations. That distinction is the actual difference between the two products: the MCP tier at $9/month, or $69/year, is for querying your own data in your own AI client, while the full coaching plan at $39/month adds a coach that watches the data continuously and starts the conversation itself. Both include a 7-day free trial. The comparison of an AI coach with a general assistant goes into where that line falls in practice.
Garmin is one source among many. The same connector exposes WHOOP, Oura, Hevy, Withings, Apple Health, Intervals.icu, TrainingPeaks, Wahoo, COROS, Polar and others through one connection. If you wear a Garmin and lift with Hevy, the model sees both, and the cross-source questions are where the answers get genuinely hard to get anywhere else. The general guide to connecting training data to ChatGPT or Claude covers the full source list.
Putting it together: a Garmin MCP setup checklist
- Connect Garmin on the integrations page and approve the OAuth scopes. Confirm the connection shows as live.
- Request an Export Your Data archive from Garmin on the same day, and upload the ZIP when it arrives. Do this once, at the start, so you never have a history gap to explain later.
- Copy your MCP URL from the dashboard. Treat it like a password, because the API key is embedded in it.
- Add the connector to your AI client of choice and confirm it reports as Connected.
- Run one verification question that needs data you have never typed, such as your longest ride of the last 90 days. If the number is right, the pipe is good.
- Ask a cross-source question next, not a single-metric one. "How does my sleep on nights after hard sessions compare to nights after easy ones?" is the kind of question that shows what the connector is for.
- Revoke the key from the dashboard if you ever share a machine or stop using a client. It takes one click and invalidates every session using it.
Your watch has been recording all of this for years. The only thing that has been missing is a way for something smart to read it without you typing it out first.
