[Cotlet](https://cotlet.dev/index.md) · [Integrations](https://cotlet.dev/integrations.md) · [How it works](https://cotlet.dev/how-it-works.md) · [Security](https://cotlet.dev/security.md) · [For developers](https://cotlet.dev/for-developers.md) · [For automation agencies](https://cotlet.dev/for-agencies.md) · [Blog](https://cotlet.dev/blog.md) · [API docs](https://cotlet.dev/docs.md) · [Help center](https://cotlet.dev/help.md) · [Changelog](https://cotlet.dev/changelog.md) · [Contact](https://cotlet.dev/contact.md) · [Pricing](https://cotlet.dev/pricing.md) · [Sign up](https://cotlet.dev/signup)

# Garmin Connect API and MCP server: Let your AI agent coach you from Garmin Connect.

> Garmin Connect has an official API but no MCP server (checked 27 Oct 2026). Since 21 Oct 2026 anyone can make a free Personal API key for their own activity and health data, pull only. Workouts and courses go in through business tiers you apply for. Cotlet runs 11 Garmin Connect tools hosted, over MCP for agents and REST for scripts.

Bring Garmin Connect activity records into your agent or private training journal. Use MCP or REST from automation tools and scripts, retaining the original units.

[MCP setup](https://cotlet.dev/integrations/garmin-api-mcp-server.md#connect)
[REST API guide](https://cotlet.dev/integrations/garmin-api-mcp-server.md#rest-api)

- Free 7-day trial, no card
- Unofficial, not affiliated with Garmin
- Page: https://cotlet.dev/integrations/garmin-api-mcp-server

## What can you automate in Garmin Connect?

- Check readiness each morning
- Review last week's runs
- Build and schedule workouts
- Export original FIT files
- Track HRV and sleep trends
- Read training status and VO2 max

## Does Garmin Connect have an MCP server or an API?

- The Personal key is for your own data. Garmin says it is not meant for commercial apps that serve other people.
- A key lasts 30 days, 90 days, 180 days or one year, and tokens last 24 hours. Garmin emails you about a week before it expires.
- Starter and Enterprise are for companies. Starter needs an access request that asks for a business model and any AI services that process the data.
- Zapier has no Garmin Connect app that we found, and n8n has no Garmin node. Make was not reachable.

| What you need | Personal API key | Open-source server | Cotlet |
|---|---|---|---|
| Read activities and files | Yes, with your own code | Yes | Yes |
| Read sleep, HRV and Body Battery | Health data, metrics not listed | Yes | Yes |
| Training status and readiness | Not listed | Some servers | Yes |
| Build and schedule workouts | No, business tiers | Some servers | Yes, schedule after your OK |
| No password or key to renew | Key expires | Password or key | Sign in once |

Checked 27 Oct 2026. Sources: [Garmin Connect Developer Program overview](https://developer.garmin.com/gc-developer-program/overview/), [Garmin Rumors: Personal, Starter and Enterprise](https://garminrumors.com/garmin-connect-developer-program-personal-starter-enterprise/), [Tredict: Garmin Personal API and AI](https://www.tredict.com/blog/garmin_personal_api_chatgpt_and_claude/), [Garmin Personal API Python client](https://github.com/garmin/connect-personal-api-python)

## How does Cotlet connect to Garmin Connect?

1. **Sign in to Garmin Connect.** Use your own account in its Cotlet Cloud Browser.
2. **Choose MCP or REST.** Connect your agent or create a Cotlet API key.
3. **Run your workflow.** Ask your agent or send an HTTP request.

We never keep your Garmin password, and nothing lands on your training calendar until you approve it.

## Connect Garmin Connect to your agent or workflow

Use MCP with your AI agent, or HTTP requests in n8n, Make, Zapier and scripts. Follow the MCP setup below or jump to the REST guide.

1. **Enable Garmin Connect for agents.** Sign up, sign in to Garmin Connect in its Cloud Browser, then press Enable for agents.
2. **Paste the Cotlet address.** Add https://cotlet.dev/mcp/v1 as an MCP server or connector in your agent.
3. **Approve the connection.** Chat apps ask you to sign in to Cotlet. Editors, n8n and scripts use an API key from the console.

The same address serves every app you enable, Garmin Connect with the rest. If you enable Garmin Connect after connecting, refresh the connector so the new tools show up.

Claude:

```
Settings > Connectors > Add custom connector
URL: https://cotlet.dev/mcp/v1/connect

Claude Code:
claude mcp add --transport http cotlet \
  https://cotlet.dev/mcp/v1 \
  --header "Authorization: Bearer $COTLET_API_KEY"
```

ChatGPT:

```
Settings > Apps & Connectors > Create
MCP server URL: https://cotlet.dev/mcp/v1/connect
Authentication: OAuth
```

Cursor:

```
// ~/.cursor/mcp.json
{
  "mcpServers": {
    "cotlet": {
      "url": "https://cotlet.dev/mcp/v1",
      "headers": { "Authorization": "Bearer ${env:COTLET_API_KEY}" }
    }
  }
}
```

Codex:

```
# ~/.codex/config.toml
[mcp_servers.cotlet]
url = "https://cotlet.dev/mcp/v1"
bearer_token_env_var = "COTLET_API_KEY"
```

n8n:

```
MCP Client Tool (inside an AI Agent)
Transport: HTTP Streamable
URL: https://cotlet.dev/mcp/v1
Auth: Bearer, <your key>
Tool: garmin_read
```

Make, Zapier:

```
Make: MCP Client > Call a tool
Zapier: MCP Client by Zapier > Run Tool
Server URL: https://cotlet.dev/mcp/v1
Token: <your key>
Tool: garmin_write
```

## How to use the Garmin Connect REST API

### Create your Cotlet API key

Create a Cotlet API key with access to Garmin Connect and its read operations. Store it as `COTLET_API_KEY` in your environment or automation platform's credential store.

Sign in to Garmin Connect in its Cotlet Cloud Browser and enable the app for agents. Use your own Garmin Connect login at connect.garmin.com.

### Make your first Garmin Connect API request

REST:

```
curl "https://cotlet.dev/api/v1/garmin/activities?limit=2" \
  -H "Authorization: Bearer $COTLET_API_KEY"
```

### Read activities and follow the cursor

A successful REST call puts the tool output in `result`. This illustrative response excerpt omits call IDs, messages and credit details.

Illustrative response excerpt:

```
{
  "status": "success",
  "app": "garmin",
  "tool": "list_activities",
  "result": {
    "activities": [
      {
        "activity_id": "9000000101",
        "name": "Long Run",
        "type": "running",
        "date": "2026-10-24",
        "distance_km": 21.1,
        "duration_min": 118,
        "avg_heart_rate": 152
      }
    ],
    "next_cursor": null
  }
}
```

Read `result.activities` and pass `result.next_cursor` unchanged as `cursor` until null. Keep date, activity-type and limit filters fixed.

Activity lists default to 25 records, with a maximum of 100. `distance_km` uses kilometers and `duration_min` uses minutes; retain those units in reports.

Device-dependent metrics can be absent. Workout lists accept at most 100 records without a cursor, so do not treat them as an unlimited export.

### Garmin Connect workflows for agents and automations

| Tool | Connect through | Example workflow |
|---|---|---|
| n8n | HTTP Request | Combine activities and activity details into a private distance and duration report with original units. |
| Make | HTTP > Make a request | Read selected activity IDs and download their files into your chosen personal archive. |
| Python or Node.js | REST API | Read dated sleep, HRV and Body Battery records into a private metric journal without interpreting absent values. |

Send `Authorization: Bearer <your Cotlet API key>` in request headers. You configure the schedule, destination and record comparisons.

Cotlet reads Garmin Connect; your workflow steps write to your chosen destination. These HTTP workflows do not require a native Cotlet connector or a prebuilt template.

Python and Node.js can use the same HTTP requests without an AI agent. Keep access keys in credentials, outside shared workflow exports.

The [API and MCP reference](https://cotlet.dev/integrations/garmin-api-mcp-server.md#tools) lists operations and inputs. The [REST API guide](https://cotlet.dev/docs/api.md) explains authentication, errors and approvals.

## Garmin Connect API endpoints and MCP tools

### Activities and files

Newest first, filtered by type and date. GPX and TCX are not offered for every activity type, and Garmin exports multisport activities only as FIT.

- **List activities** (`list_activities`, read): Activities with type, date, distance, duration and average heart rate.
- **Get activity** (`get_activity`, read): One activity with its summary, splits and heart rate zones.
- **Download activity file** (`download_activity`, read): The activity as its original FIT file, or as GPX or TCX.

### Sleep, HRV and training status

Read only. HRV status needs about three weeks of sleep data, and training readiness comes back empty on devices that do not calculate it.

- **Get sleep** (`get_sleep`, read): One night of sleep: score, total time and sleep stages.
- **Get HRV status** (`get_hrv_status`, read): Overnight heart rate variability and the HRV status Garmin assigns.
- **Get Body Battery** (`get_body_battery`, read): Body Battery for a day: the morning level, the day's high and low, and what drained it.
- **Get training status** (`get_training_status`, read): Training status, training readiness and VO2 max as Garmin Connect shows them.

### Workouts and training calendar

A new workout sits in your library until you schedule it. Scheduling changes what your calendar, and later your watch, shows.

- **List workouts** (`list_workouts`, read): Workouts in your library, with name, sport and number of steps.
- **Get training calendar** (`get_training_calendar`, read): Scheduled workouts and activities on your calendar in a date range.
- **Create workout** (`create_workout`, write): New workout in your library from a list of steps. It is not scheduled or sent anywhere.
- **Schedule workout** (`schedule_workout`, write, asks first): Put a workout from your library on a date in your training calendar.

Inputs, REST path and example response of every tool: https://cotlet.dev/integrations/garmin-api-mcp-server#tools

## Who can see my Garmin Connect session, and how do I revoke it?

- **What we store.** Your signed-in Garmin Connect profile, encrypted with AES-256-GCM, in Finland. Not the password.
- **What your agent gets.** The 11 Garmin Connect tools. Never the cookie or your password.
- **What the session sees.** Your account: activities, sleep and health stats, workouts, calendar.
- **What no tool touches.** Password, two-factor, subscription, devices, sharing and deleting.
- **If Garmin asks to verify.** A sign-in code or challenge goes to you. You type it in, we never do.
- **How to cut access.** Disable for agents, reset the browser, or sign out of Garmin Connect.

Our site scores A+ on Qualys SSL Labs, securityheaders.com and Mozilla Observatory ([live results](https://cotlet.dev/security.md)). There is no SOC 2 report or third-party pentest yet.

## Is it against Garmin's terms? Account safety

> Licensees may not use the API to design a client or application that uses any robot, spider, site search, or other retrieval application or device to scrape, retrieve, or index services provided by Garmin or its licensors.
>
> [Garmin Connect Developer Program Agreement, restrictions](https://www8.garmin.com/en-US/GARMINCONNECTDEVELOPERPROGRAMAGREEMENT/GARMINCONNECTDEVELOPERPROGRAMAGREEMENT_EN.pdf)

That clause binds developers who sign the API agreement, and Cotlet does not use the API. We could not open Garmin's consumer terms of use, so we quote nothing from them (checked 27 Oct 2026). Garmin could still read an agent in your account as automation. In 2026 Garmin put Cloudflare TLS fingerprinting in front of its Connect API, which blocks scripts that are not a real browser. We found no public case of a Garmin account closed for using a third-party tool, only temporary rate limits.

How we keep your account looking like you:

- Your own Garmin account, signed in by you
- A real Chrome in one Cloud Browser with its own IP and cookies
- Workouts reach your calendar only after your OK
- No tool deletes an activity or a workout
- If Garmin objects, we pause the Garmin tools for everyone within 24 h

> Garmin limits repeated sign-ins from one account. Sign in once and let the Cloud Browser keep the session instead of logging in on every run.

## What happens when Garmin Connect changes?

- **12 h** between tests of the Garmin Connect reads
- **$0** for a call to a Garmin Connect tool paused for repair

Garmin changed its sign-in this year and broke several open-source servers. When Garmin Connect moves a button or renames a field, the fix happens on our side and your prompts keep working. [status.cotlet.dev](https://status.cotlet.dev) watches the site, console and API every 3 minutes.

## Approvals, undo and mistakes

1. **Reads your state.** Sleep, HRV, Body Battery and the calendar for the week.
2. **Builds the workouts.** Steps, durations and targets saved to your library.
3. **Waits for your OK.** The schedule shows up in your Cotlet console first.
4. **Reports the plan.** Each workout, its date and what it replaced.

| Action | Undo |
|---|---|
| Create a workout | Delete it in Garmin Connect, it reaches no one |
| Schedule a workout | Remove it from the calendar in Garmin Connect |
| Workout already on the watch | Garmin sends the calendar to the device and overwrites the one there, so check it before you OK |
| Download a file | Nothing changes in your account |

1 of 11 tools asks first: schedule_workout, the one that changes your training calendar. Reads, downloads and new library workouts reach nothing, so they run at once. Switch the wait off per tool for a scheduled run.

> Garmin's manuals say scheduled workouts sent to a device overwrite the training calendar already on it. Look at get_training_calendar before you approve a new week.

MCP call:

```
{
  "name": "schedule_workout",
  "arguments": {
    "workout_id": "wk_3301",
    "date": "2026-10-29"
  }
}
```

REST:

```
curl -X POST https://cotlet.dev/api/v1/garmin/workouts/wk_3301/schedule \
  -H "Authorization: Bearer $COTLET_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"date":"2026-10-29"}'
```

Tool output:

```
{
  "workout_id": "wk_3301",
  "date": "2026-10-29",
  "status": "scheduled",
  "name": "Tempo 3 x 10 min"
}
```

Scripts and cron jobs reach the same tools over REST at `/api/v1/garmin`, with the same key and price. A device that does not record a metric returns it empty, and a failed call costs nothing. The tools table lists the REST path of each tool.

## How much does the Garmin Connect MCP server cost?

**About $21 a month** for a daily readiness check plus weekly review, planning and exports, 3,680 credits. Garmin Connect stays free, or Connect+ at Garmin's own price.

| Job | Calls | Credits |
|---|---|---|
| Morning readiness check | 5 × 30 | 1,500 |
| Review the week's runs, weekly | 5 × 4 | 200 |
| Build and schedule a training week | 7 × 4 | 280 |
| Export files for a coach, weekly | 5 × 4 | 200 |
| Cloud Browser, 30 days |  | 1,500 |
| Total |  | 3,680 |

- Free 7-day trial, no card
- 10 credits per successful call, MCP or REST
- 50 credits a day for the Cloud Browser
- Works on the free Garmin Connect account

The month is our example: a morning check every day and a weekly review, plan and export. We found no public figure for how an athlete uses an agent on Garmin Connect. Garmin Connect+ costs $6.99 a month or $69.99 a year in the US (checked 27 Oct 2026) and is billed by Garmin. Dollars at the $29 pack rate.

## Garmin Connect MCP server on GitHub or hosted: which to use

| Option | What it does | Where it stops |
|---|---|---|
| [Taxuspt/garmin_mcp](https://github.com/Taxuspt/garmin_mcp) | MCP server with activities, health, workouts, calendar and device tools, in tool profiles from 20 to all. Python, MIT. | 1,416 stars, last commit 24 Oct 2026. Signs in with your Garmin email and password through an unofficial library; Garmin's login changes have broken that route before. |
| [Nicolasvegam/garmin-connect-mcp](https://github.com/Nicolasvegam/garmin-connect-mcp) | 61 tools over seven categories, Node.js. | 185 stars, last commit 28 Jul 2026. Takes your email and password in the environment. |
| [etweisberg/garmin-connect-mcp](https://github.com/etweisberg/garmin-connect-mcp) | Routes calls through a headless Playwright browser to get past Garmin's TLS fingerprinting, with workouts and devices. | 45 stars, last commit 12 Jul 2026. You log in by hand in a Playwright browser and keep it running; AGPL-3.0. |
| [Mason-Levyy/garmin-personal-mcp](https://github.com/Mason-Levyy/garmin-personal-mcp) | 26 read-only tools on the official Personal API, no password. Python, MIT. | 39 stars, last commit 25 Oct 2026. Reads only, and you renew the key every 30 days to a year. |
| [Tredict](https://www.tredict.com/blog/garmin_personal_api_chatgpt_and_claude/) | Training platform on Garmin's official business API, with an MCP server and a ChatGPT plugin. Sends workouts to the watch. | You move your training log into Tredict. It works from its own data, not your Garmin account. |

A GitHub server is free and quick to start if you are comfortable with a terminal and a stored password or key. It runs on your computer and stops when Garmin changes its login. The Personal API route is clean but read-only. Cotlet keeps your Garmin account as the source of truth, hosts the server, adds the workout tools and repairs it when Garmin changes.

## Who runs Cotlet

Take Group sp. z o.o. runs Cotlet. It is a software company registered in Poland, EU (VAT PL6342984273), working since 2019, founded by Bart Krawczyk (Co-founder, CTO) and Jake Slugocki (Co-founder, SEO, sales and marketing). Write to contact@cotlet.dev with questions about the Garmin Connect tools.

## Garmin Connect API and MCP: questions

### Can I use the Garmin Connect API without an AI agent?

Yes. Call Cotlet's REST API from a script or an HTTP step in n8n, Make or Zapier with your Cotlet key. MCP is the alternative for AI agents; you do not need to connect an agent to use REST.

### How do I get access?

Create a free account at https://cotlet.dev, open Garmin Connect under Integrations in the console and sign in to Garmin Connect in its Cloud Browser. The trial starts with your first app, no card asked.

### Why not use Garmin's free Personal API key?

For reading your own activity and health data, you can (checked 27 Oct 2026). The key is read-only, pull only and expires after 30 days to a year, and you need your own code or an open-source server to use it. Cotlet is for what the key does not do: building and scheduling workouts, and training status, in a hosted server.

### Does a scheduled workout reach my watch?

Scheduling puts the workout on your Garmin Connect training calendar. Garmin's manuals say workouts sent from Connect to the device overwrite the training calendar already on it, so check the calendar before you confirm.

### Do I need Garmin Connect+?

No for the tools here. Cotlet works in your account on the plan you have. Features Garmin sells with Connect+, such as nutrition tracking, need that subscription in Garmin first (checked 27 Oct 2026).

### Does Garmin Connect have webhooks?

Only for approved businesses. Starter and Enterprise push data to an app's server, while the Personal tier is pull only (checked 27 Oct 2026). Run your agent on a schedule instead, for example a daily get_sleep and get_training_status pass.

### Does it work with any Garmin watch?

Cotlet reads what Garmin Connect shows for your account. A device that does not record a metric, such as HRV status or training readiness, returns it empty.

### Can the agent see my Garmin password?

No. We keep the signed-in session, never the password, and no tool returns the cookie.

### Is the MCP server different from the REST API?

Only the way in. Both have the same 11 tools, inputs and answers, one API key and one price. Agents use MCP; scripts, cron jobs and HTTP steps use REST.

### Is Cotlet affiliated with Garmin?

No. Cotlet is independent and not affiliated with Garmin Ltd.

---

Give your AI agents your signed-in browser.

**Product:** [Integrations](https://cotlet.dev/integrations.md) · [How it works](https://cotlet.dev/how-it-works.md) · [Pricing](https://cotlet.dev/pricing.md) · [Security](https://cotlet.dev/security.md)

**Resources:** [Blog](https://cotlet.dev/blog.md) · [API docs](https://cotlet.dev/docs.md) · [Help center](https://cotlet.dev/help.md) · [Changelog](https://cotlet.dev/changelog.md) · [GitHub](https://github.com/cotletdev/cotlet)

**Solutions:** [For developers](https://cotlet.dev/for-developers.md) · [For automation agencies](https://cotlet.dev/for-agencies.md)

**Company:** [About](https://cotlet.dev/about.md) · [AI info: company facts](https://cotlet.dev/ai-info.md) · [Contact](https://cotlet.dev/contact.md)

**Legal:** [Terms of service](https://cotlet.dev/terms) · [Privacy policy](https://cotlet.dev/privacy) · [Refund policy](https://cotlet.dev/refunds) · [Acceptable use](https://cotlet.dev/acceptable-use) · [Cookie policy](https://cotlet.dev/cookies) · [DPA](https://cotlet.dev/dpa) · [Subprocessors](https://cotlet.dev/subprocessors)

**Elsewhere:** [Status page](https://status.cotlet.dev) · [Cotlet on GitHub](https://github.com/cotletdev) · [Cotlet on X](https://x.com/cotletdev) · [Cotlet on LinkedIn](https://www.linkedin.com/company/cotletdev) · [Cotlet on Product Hunt](https://www.producthunt.com/products/cotlet) · [Cotlet on Crunchbase](https://www.crunchbase.com/organization/cotlet) · [Cotlet on SaaSHub](https://www.saashub.com/cotlet)

Cotlet.dev is built by Bart Krawczyk and Jake Slugocki, the founders of Take Group sp. z o.o., ul. Wincentego Janasa 4, 40-855 Katowice, Poland. KRS 0000871398, NIP 6342984273, VAT EU: PL6342984273. [About us](https://cotlet.dev/about.md)

Cotlet is an independent service. It is not affiliated with, endorsed by or sponsored by any of the products listed on this site. Product names are trademarks of their respective owners.
