COROS MCP Server: Connect COROS to Claude and ChatGPT

You ask Claude about your build and it asks you to describe it

You have been building for eleven weeks. Every run, every ride, every threshold session sits in your COROS account with GPS, pace, heart rate, power and lap structure attached. EvoLab has been quietly computing Base Fitness and Fatigue the whole time.

So you open Claude and ask whether you are ready to raise the long run. And it asks you what your training has looked like.

You type a summary. Roughly 60 kilometers a week, one threshold session, one long run, feeling alright. The model gives you a well-reasoned answer built on a paragraph, when the actual answer lives in eleven weeks of laps. It does not know your last three long runs each drifted 6 to 9 BPM in the final 40 minutes. It does not know your resting heart rate has been two beats above your spring baseline for nine days.

The model is not the problem. It is blind, and you cannot type your way out of blindness. An MCP server fixes that at the root: instead of you summarizing the block, the model reads it.

What MCP actually is

The Model Context Protocol is an open standard for letting AI assistants call external tools. Anthropic published it in late 2024 and it has since been adopted well beyond Claude, with ChatGPT, Cursor and Perplexity all speaking it.

The protocol 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 one. Results come back as structured data the model can reason over.

For endurance training data that shape is exactly right. You do not want eleven weeks of activities pasted into a context window, going stale the moment you finish tomorrow's session. You want the model to ask a question when it needs an answer, the same way you would open the COROS app and scroll to a specific week.

So "COROS MCP server" means a server that exposes your COROS history as tools. Ask "did my aerobic decoupling on long runs get better or worse across this block?" and the model fetches both windows and does the comparison against real laps.

Why the setup is a sign-in rather than a key

This is the part that trips people up, so it is worth being direct about it.

Search for a COROS API key and you will find that there is not one to find. COROS runs a partner program rather than a self-serve developer portal, so an individual athlete has no supported route to credentials for their own account. That is different from Garmin, which will let you build against an approved app, and different again from Hevy, which hands you a key behind a subscription.

The practical consequence is that a self-hosted COROS MCP project has nothing legitimate to authenticate with. What exists instead is an authorized data bridge: you sign in to COROS once through the connect flow, COROS grants access, and activities and wellness data stream in from then on. From your side it is one sign-in. From the connector's side it is a supported integration rather than a scraper that breaks when COROS ships an app update.

It also means the grant is at the account level, not the device level. Any watch that syncs into your COROS account is covered, and swapping a PACE for a VERTIX changes nothing about the connection.

What the COROS connector exposes

Once COROS is connected, the model gets two layers of tools.

The COROS layer. terra_get_activities returns your sessions for a window with pace, heart rate, power, cadence and distance. terra_get_recent_data gives a snapshot of everything COROS knows about you right now, activities plus the wellness scalars. terra_get_interval_breakdown returns the lap structure of a single session, which is what turns "I did threshold reps" into six laps with per-lap pace and heart rate the model can actually inspect.

Cadence deserves a note, because it is a common source of wrong numbers. COROS reports run cadence per leg, around 80, rather than as total steps per minute. The normalizer doubles it on ingest so that every run in your history uses one convention. A model reading the raw field would otherwise tell you that you run at 80 steps per minute.

The derived layer. These are not COROS fields at all. They are computed across everything you have connected: get_pmc_status for fitness and fatigue balance, get_pace_curve and get_power_curve for best efforts by duration, get_training_trends, get_load_balance across sports, get_injury_risk, get_readiness_today, get_daily_metrics for the HRV and resting heart rate series, and get_activity_detail for one session in depth.

This second layer is usually where the conversation gets interesting, because EvoLab gives you a Base Fitness number and a Fatigue number but no screen that answers "is my 42-day ramp steeper than the two blocks that preceded my last two injuries". The training stress score guide covers what those load numbers mean; the point here is that a model with tool access can compute the comparison rather than describing the concept.

What lands and what does not

Being precise about this matters more than it sounds, because the failure mode is not an error message. It is a confident answer built on a field that was never there.

Lands: activities with GPS, pace, heart rate, power, cadence and lap structure. Overnight HRV. Resting heart rate. Weight and body fat if you log them. Sleep as a nightly total.

Does not land: VO2max. Sleep stages, meaning deep, light and REM. COROS's own sleep score.

The sleep constraint is the one worth internalizing. COROS ships no stage breakdown through the bridge, so a nightly total is the honest ceiling. That is genuinely less than a Garmin or an Oura gives you, and any tool that splits your COROS night into stages is inventing them.

It matters less than it looks, though. Overnight HRV and resting heart rate are the two signals with the strongest evidence behind them for guiding day-to-day training decisions, and both come through cleanly. Work like Plews and Buchheit's on HRV-guided training rests on the daily HRV series and its rolling baseline, not on the stage split. The HRV guided training guide covers how to read that series without overreacting to a single bad morning.

Setting it up

The whole flow is about five minutes, and most of it is COROS's sign-in screen.

1. Connect COROS. Sign in at athletedata.health, open the COROS integration page, and click Connect. Sign in with your COROS account and approve. You come back with the connection live and a backfill already running.

2. Let the backfill finish. History streams in over minutes rather than instantly, and it covers real history rather than a rolling 30-day window. It is worth waiting for the first pass to complete before you ask the model anything comparative, or you will get an answer about a partially loaded season.

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 panel, and there are step-by-step pages for all of them in the MCP setup section.

5. Ask it something specific. Open a new chat and ask a question that needs data you have never typed, for example "what was my weekly load across the last eight weeks, and how does my HRV trend line up against it?" 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 shift is not that the model can recite your sessions. It is that you stop pre-filtering.

When you type your own context, you decide in advance what matters. You mention the threshold session that felt bad, because that is the story you noticed. You do not mention that you have slept 40 minutes short for nine straight nights, because you did not connect the two. With tools available, the model can go looking.

A worked example. 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, pulls your HRV series from get_daily_metrics, checks get_pmc_status, notices your HRV has sat below baseline for four days while acute load climbed, and gives you the specific thing: move it to Thursday, keep tomorrow at 60 minutes easy.

Lap-level questions are the other place this pulls ahead. "In my last six threshold sessions, did my heart rate at target pace drift up or down?" is a question with a real answer sitting in terra_get_interval_breakdown, and it is effectively unanswerable by scrolling an app.

The limits worth knowing about

No self-serve COROS API. Covered above, but it is the single most common reason people arrive at this page. If you were looking for credentials to build your own COROS integration, they are not available to individuals, and no configuration will conjure them.

The plan sync is one-directional. COROS is one of a small set of platforms that accept a pushed structured workout, so a session built in a conversation can land on the watch. But a plan that you or a human coach built in COROS Training Hub cannot be read back. In practice that means picking one owner for the plan. The COROS AI coach guide goes into that tradeoff properly.

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. If COROS is your primary device this changes nothing, since your activities already arrive from COROS directly.

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 runs between your conversations. That is the real 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 continuously and starts the conversation itself. Both include a 7-day free trial.

COROS is one source among many. The same connector exposes Garmin, WHOOP, Oura, Hevy, Withings, Apple Health, Intervals.icu, TrainingPeaks, Wahoo, Polar and others through one connection. If you race on a COROS and sleep on an Oura, the model sees both, and the cross-source questions are where the answers get genuinely hard to get anywhere else. The Garmin MCP server guide covers the equivalent setup on that side, and the general guide to connecting training data to ChatGPT or Claude has the full source list.

Putting it together: a COROS MCP setup checklist

1. Connect COROS on the integrations page and sign in when the COROS screen appears. Confirm the connection shows as live.
2. Wait for the initial backfill to finish before asking anything that compares two periods. A partially loaded history produces a confidently wrong comparison.
3. Copy your MCP URL from the dashboard. Treat it like a password, because the API key is embedded in it.
4. Add the connector to your AI client of choice and confirm it reports as Connected.
5. Run one verification question that needs data you have never typed, such as your longest run of the last 90 days. If the number is right, the pipe is good.
6. Ask a lap-level question next, not a summary one. "How did my heart rate at threshold pace change across my last six interval sessions?" is the kind of question this exists for.
7. Remember what does not land. If an answer starts splitting your COROS nights into deep and REM, it is inventing them, and that is worth correcting immediately rather than building on.
8. 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, and EvoLab has been doing real analysis on it the whole time. What was missing was a way to ask it a question that COROS never built a screen for.