# durely insights MCP for Garmin (npm · @durely/garmin-insights-mcp)

Your full Garmin history, kept locally, analysed down to the second, via the official Personal API.

- Trust score: 81/100 (high trust)
- Change this week: +15
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-11-05

## Components

- npm · `@durely/garmin-insights-mcp`: 81/100 (this document), [markdown](https://verifymcp.io/servers/app-durely-garmin-insights-mcp/durely-garmin-insights-mcp.md), [page](https://verifymcp.io/servers/app-durely-garmin-insights-mcp/durely-garmin-insights-mcp)
- oci · `ghcr.io/durely/garmin-insights-mcp`: 44/100, [markdown](https://verifymcp.io/servers/app-durely-garmin-insights-mcp/ghcr-io-durely-garmin-insights-mcp.md), [page](https://verifymcp.io/servers/app-durely-garmin-insights-mcp/ghcr-io-durely-garmin-insights-mcp)

## Channel facts

- Registry: `npm`
- Package: `@durely/garmin-insights-mcp`
- Version: `0.5.2`
- Transport: `stdio`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically from public evidence about the published package, including repeated runs of it in an isolated sandbox, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-11-05.

- **Supply Chain Security**: 99/100
  - No malware found by supply-chain analysis.
  - No known CVEs affecting this package version or its production dependencies.
  - No install/post-install scripts declared.
  - 3 of 8 dependencies flagged as unhealthy.
- **Provenance & Transparency**: 100/100
  - Source repository is publicly reachable at the declared URL.
  - Cryptographically verified build provenance (signed, bound to durely/garmin-insights-mcp).
  - Clear OSI-approved license (Apache-2.0).
  - Actively maintained (last published 6 days ago).
  - Publishes a security disclosure policy (SECURITY.md).
- **Schema Quality & AI Usability**: 75/100
  - 100% of prompts and resources have a non-trivial description (not blank, and not just the item's name).
  - AI-judged instruction clarity (good).
  - Context-footprint check failed: tool/resource definitions use about 5250 tokens (~238/item across 22 items; 21 tools + 1 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 0/100
  - Stability not yet verified: not enough scan history yet (needs a 30-day window).
- **Tool Coverage**: 97/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 92% of tool parameters carry a description.
- **Tool Safety**: 100/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - We read all 21 captured tool definition(s), and no name or description among them implies an irreversible operation.
  - An AI judge read all 23 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 100/100
  - Implements a current MCP spec version (2026-07-28).

**Unverified: 1 category.** A category scored 0 because we could not verify it: a data source with nothing on this package, evidence we could not reach, or a check we could not run. We only credit what we can confirm.

## Install

### How do I install the durely insights MCP for Garmin server?

durely insights MCP for Garmin runs locally as an npm package, launched with npx -y @durely/garmin-insights-mcp. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation.

### Claude

```bash
claude mcp add app-durely-garmin-insights-mcp -- npx -y @durely/garmin-insights-mcp
```

### Cursor

```json
{
  "mcpServers": {
    "app-durely-garmin-insights-mcp": {
      "command": "npx",
      "args": [
        "-y",
        "@durely/garmin-insights-mcp"
      ]
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "app-durely-garmin-insights-mcp": {
      "command": "npx",
      "args": [
        "-y",
        "@durely/garmin-insights-mcp"
      ]
    }
  }
}
```

### Codex

```bash
codex mcp add app-durely-garmin-insights-mcp -- npx -y @durely/garmin-insights-mcp
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "app-durely-garmin-insights-mcp": {
      "type": "local",
      "command": [
        "npx",
        "-y",
        "@durely/garmin-insights-mcp"
      ],
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add app-durely-garmin-insights-mcp --command npx --arg -y --arg @durely/garmin-insights-mcp
```

### Hermes

```yaml
mcp_servers:
  app-durely-garmin-insights-mcp:
    command: "npx"
    args: ["-y", "@durely/garmin-insights-mcp"]
```

### Netclaw

```json
{
  "McpServers": {
    "app-durely-garmin-insights-mcp": {
      "Transport": "stdio",
      "Command": "npx",
      "Arguments": [
        "-y",
        "@durely/garmin-insights-mcp"
      ]
    }
  }
}
```

### Vellum

```bash
assistant mcp add app-durely-garmin-insights-mcp -t stdio -c npx -a -y @durely/garmin-insights-mcp
```

### Other

```json
{
  "mcpServers": {
    "app-durely-garmin-insights-mcp": {
      "command": "npx",
      "args": [
        "-y",
        "@durely/garmin-insights-mcp"
      ]
    }
  }
}
```

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-10-30 (score 81, +15)

- [security improvement] Malware scan: unverified → pass

### 2026-10-29 (score 66)

First indexed and scored.

## MCP tools (21)

### `garmin_status` (~124 tokens)

Garmin connection status

Check that the Garmin Personal API connection works and report its configuration.

Reports: where the API key comes from, whether a token could be obtained and when it expires, the API key's expiry (if GARMIN_API_KEY_EXPIRES is set), the time zone used for calendar dates, and the server version.

Use this first when another garmin_* tool fails with an authentication error, or when the user asks whether their Garmin connection is set up.

Input parameters:

- `response_format` (string): 'markdown' for readable text (default), 'json' for complete structured data

### `garmin_get_profile` (~125 tokens)

Get Garmin profile and zones

Get the user's Garmin profile settings, heart rate zones per sport, and fitness age.

Returns: units and locale, time zone, preferred training days, HR zone floors per sport (with the max HR / LTHR / resting HR used to compute them), and the latest fitness age.

Use this before interpreting heart rate data (to know the user's zones), or when the user asks about their zones, max HR, lactate threshold or fitness age.

Input parameters:

- `response_format` (string): 'markdown' for readable text (default), 'json' for complete structured data

### `garmin_list_activities` (~563 tokens)

List Garmin activities

Search the user's Garmin activities (all history, from the local cache), newest first by default.

Returns one page of compact summaries plus the total number of matches: id, date, type, name, duration, distance, pace/speed, HR, power, elevation, training effect, training load, TSS/IF and VO2max where available, plus time in HR/power zones (JSON mode).

Examples:
  \- "My runs this month" -> activity_type="running", start_date="2026-10-01"
  \- "Longest rides ever" -> activity_type="cycling", sort_by="distance"
  \- "Zwift sessions" -> activity_type="virtual_ride"
  \- "Triathlon bike legs" -> include_multisport_legs=true, activity_type="road_biking"

The cache refreshes automatically when it's more than an hour old. Use garmin_get_activity for one activity's full details (splits, FTP, workout).

Input parameters:

- `activity_type` (string): Garmin activity type or parent type. Parent types include their subtypes: running (trail_running, treadmill_running, track_running, virtual_run), cycling (road_biking, virtual_ride, indoor_cycling, m…
- `end_date` (string): Only activities on or before this local date, yyyy-MM-dd
- `include_multisport_legs` (boolean): false (default): multisport activities appear once, as the parent. true: show their individual legs (swim/bike/run/transitions) instead of the parent, e.g. so triathlon bike legs count as cycling vol…
- `limit` (integer): Maximum activities to return (1-100)
- `max_distance_km` (number): Maximum distance in km
- `max_duration_min` (number): Maximum duration in minutes
- `min_distance_km` (number): Minimum distance in km
- `min_duration_min` (number): Minimum duration in minutes
- `offset` (integer): Number of activities to skip, for pagination
- `response_format` (string): 'markdown' for readable text (default), 'json' for complete structured data
- `search` (string): Text to match in the activity name (case-insensitive)
- `sort_by` (string): Sort field
- `sort_order` (string): desc = newest/largest first
- `start_date` (string): Only activities on or after this local date, yyyy-MM-dd

### `garmin_get_activity` (~198 tokens)

Get Garmin activity details

Get full details for one Garmin activity by ID.

Returns: name, description, type, start time and time zone, device, summary metrics (duration, distance, speeds, HR min/avg/max, power avg/max/NP/20-min, FTP, cadence, stride, calories, training effect + message, training load, TSS, IF, temperature, intensity minutes), split summaries (e.g. run/walk/stand intervals), the structured workout if one was followed, and multisport parent/child IDs.

Get IDs from garmin_list_activities. Example: "Tell me about yesterday's run" -> list activities for that date, then call this with its id.

Input parameters:

- `activity_id` (integer, required): Garmin activity ID from garmin_list_activities, e.g. 12345678901
- `response_format` (string): 'markdown' for readable text (default), 'json' for complete structured data

### `garmin_get_activity_laps` (~225 tokens)

Get activity laps

Get the laps (and sessions, swim lengths and Garmin's physiological metrics) of one activity, from its original FIT file.

Returns per lap: start offset, duration (elapsed and timer), distance, pace/speed, avg/max HR, avg/max/normalized power, cadence, ascent/descent, intensity (active/rest/warmup/cooldown) and lap trigger; for swims, stroke and lengths. Also: device, multisport sessions, and FIT-only metrics when the device recorded them (VO2max, recovery time, lactate threshold HR/power).

Use it for interval sessions, splits and pacing. Downloads the FIT file on first use (one request), then it's cached. For a multisport leg ID, returns only that leg's laps.

Input parameters:

- `activity_id` (integer, required): Garmin activity ID from garmin_list_activities
- `lap_offset` (integer): Skip this many laps (for activities with very many laps)
- `response_format` (string): 'markdown' for readable text (default), 'json' for complete structured data

### `garmin_get_activity_streams` (~431 tokens)

Get activity time series

Get second-by-second data from one activity's FIT file, downsampled to fit in context.

Returns per field min/avg/max over the window, plus columnar series: t (seconds from the start of the activity, or of the leg for a multisport leg) and one array per field. Units: heart_rate bpm, power W, speed m/s, cadence steps/min (running) or rpm (cycling) or strokes/min, altitude m, distance m (cumulative), temperature °C, respiration_rate breaths/min, performance_condition (Garmin's -20..+20 score), vertical_oscillation mm, stance_time ms. Cadence averages leave out zeros.

Defaults to heart_rate, power, speed, cadence, altitude (whichever the activity has) at 10 s resolution, at most 500 points; the resolution coarsens automatically for long activities. Zoom in with start_s/end_s (e.g. one interval from garmin_get_activity_laps' start offsets) and a smaller resolution_s.

"position" adds GPS latitude/longitude and reveals where the user was: only request it when the user asks for location or route analysis. Developer fields (e.g. running power from a Connect IQ app) can be requested by the name listed in available_fields, like "dev_RP_Power".

Input parameters:

- `activity_id` (integer, required): Garmin activity ID from garmin_list_activities
- `end_s` (number): Window end, seconds from the start
- `fields` (array): Fields to return: heart_rate, power, speed, cadence, altitude, distance, temperature, respiration_rate, performance_condition, vertical_oscillation, stance_time, position, or a dev_* field
- `max_points` (integer): Upper bound on points returned
- `resolution_s` (integer): Seconds per point (minimum)
- `response_format` (string): 'json' (default) for the full series, 'markdown' for stats and a short preview table
- `start_s` (number): Window start, seconds from the start

### `garmin_download_activity_fit` (~114 tokens)

Export activity FIT file

Save the original FIT file of an activity to the server's exports folder and return its path, e.g. to import it into another tool (Intervals.icu, Golden Cheetah, a spreadsheet converter).

The file is exactly what the device recorded. Saved as <data dir>/exports/<activity_id>.fit; an existing export is kept, not overwritten. For a multisport leg, exports the whole multisport file.

Input parameters:

- `activity_id` (integer, required): Garmin activity ID from garmin_list_activities

### `garmin_get_daily_health` (~295 tokens)

Daily health and recovery

Get day-by-day wellness and recovery data, from the local cache (all history).

Per day: steps (+ goal), floors, resting/min/max heart rate, stress (average, max, % of the day at rest/low/medium/high), Body Battery (min, max, charged, drained), intensity minutes (moderate, vigorous), calories (total, active), respiration, hydration, plus that night's sleep (duration, score) and HRV (last-night average, status).

group_by="week" (Monday-based) or "month" aggregates: averages per day, minimums/maximums for min_hr/max_hr/stress_max, and totals plus per-day averages for steps and intensity minutes.

Defaults to the last 14 days. Daily rows are limited to 92 days per call; use group_by="week" or "month" for longer periods (e.g. a year by week). Today's values are partial.

Examples: "How's my recovery this week?" → defaults. "Resting HR trend this year" → start_date="2026-01-01", group_by="week".

Input parameters:

- `end_date` (string): Defaults to today
- `group_by` (string)
- `response_format` (string): 'markdown' for readable text (default), 'json' for complete structured data
- `start_date` (string): Local calendar date, yyyy-MM-dd

### `garmin_get_sleep` (~159 tokens)

Sleep

Get nightly sleep from the local cache: bed and wake time, total sleep, deep/light/REM/awake time, naps, sleep score with quality and Garmin's feedback, awake count, average respiration and sleep stress. JSON mode adds the sleep score's components (duration, stress, deep/light/REM %, restlessness, awake count) with Garmin's rating each.

A night belongs to the date you woke up. Defaults to the last 14 nights, at most 92 per call.

Input parameters:

- `end_date` (string): Defaults to today
- `response_format` (string): 'markdown' for readable text (default), 'json' for complete structured data
- `start_date` (string): Local calendar date, yyyy-MM-dd

### `garmin_get_hrv` (~197 tokens)

Heart rate variability

Get nightly HRV (heart rate variability, in ms) from the local cache: last-night average, highest 5-minute value, 7-day average, the personal baseline range (balanced low/high) and Garmin's status (BALANCED, UNBALANCED, LOW, POOR).

With readings_date, also returns that night's 5-minute HRV readings (fetched from Garmin if older than the synced detail window).

Defaults to the last 28 nights, at most 366 per call. HRV needs a compatible watch worn overnight; history starts when that began.

Input parameters:

- `end_date` (string): Defaults to today
- `readings_date` (string): Night (wake-up date) to include 5-minute readings for
- `response_format` (string): 'markdown' for readable text (default), 'json' for complete structured data
- `start_date` (string): Local calendar date, yyyy-MM-dd

### `garmin_get_intraday` (~238 tokens)

Intraday health data

Get one day's health data through the day, averaged into intervals: heart rate (bpm), Body Battery (0-100), overnight HRV readings (ms) and SpO2 (pulse ox, %).

Returns per metric: min/avg/max, the day's summary values (e.g. resting HR, Body Battery charged/drained, SpO2 averages), and a columnar series (local times "HH:MM" + values). Synced for the last 150 days; older days are fetched from Garmin on demand. Garmin itself keeps intraday heart rate and HRV readings for only about 4–5 months (Body Battery longer), so older days may have just the day summary.

Defaults to today, all four metrics, 15-minute intervals. HRV and SpO2 need a compatible watch (SpO2 also needs pulse ox enabled).

Input parameters:

- `date` (string): Defaults to today
- `interval_min` (integer): Minutes per point
- `metrics` (array)
- `response_format` (string): 'markdown' for readable text (default), 'json' for complete structured data

### `garmin_get_body_composition` (~136 tokens)

Weight and body composition

Get weigh-ins from the local cache: weight (kg), BMI, body fat %, body water %, muscle and bone mass (kg), visceral fat, and where each came from (scale, manual, linked app). Includes the change over the period and the weight goal if one is set.

Only days with a weigh-in appear. Defaults to the last 365 days.

Input parameters:

- `end_date` (string): Defaults to today
- `response_format` (string): 'markdown' for readable text (default), 'json' for complete structured data
- `start_date` (string): Local calendar date, yyyy-MM-dd

### `garmin_get_nutrition` (~133 tokens)

Nutrition and hydration

Get food logged in Garmin Connect (or a linked app such as MyFitnessPal) per day: calories, carbs, protein and fat against the day's goals, and meals; plus hydration (ml) from the daily summary.

Food logs are fetched from Garmin on demand and cached. Defaults to the last 7 days, at most 31 per call.

Input parameters:

- `end_date` (string): Defaults to today
- `response_format` (string): 'markdown' for readable text (default), 'json' for complete structured data
- `start_date` (string): Local calendar date, yyyy-MM-dd

### `garmin_get_womens_health` (~120 tokens)

Menstrual cycle

Get menstrual cycle tracking from Garmin Connect for a date: cycle day, current phase and days until the next, period and cycle length, predicted next cycle, fertile window and ovulation date, plus that day's logged symptoms and notes (day view). Fetched live from Garmin.

Returns a clear "not tracked" message when cycle tracking isn't set up. Defaults to today.

Input parameters:

- `date` (string): Defaults to today
- `response_format` (string): 'markdown' for readable text (default), 'json' for complete structured data

### `garmin_analyze_activity` (~278 tokens)

Analyze an activity

Compute training metrics for one activity from its second-by-second FIT data:
\- time in heart rate zones (the user's Garmin zones for that sport) and, with an FTP, in power zones (Coggan)
\- power: average, normalized power (NP), variability index, intensity factor and TSS (needs FTP)
\- aerobic decoupling: drift of power or pace per heartbeat between the first and second half (<5% is good for steady efforts of 45+ min)
\- first vs second half (negative/positive split)
\- best efforts: power over 5 s–60 min, heart rate over 1–60 min, fastest 400 m–marathon (running), 5–90 km (cycling), 100 m–3.8 km (swimming)
\- Edwards TRIMP (zone-weighted minutes) and detected work intervals with their consistency

FTP comes from ftp_w, else from the activity's own record (Garmin cycling FTP). Works for multisport legs too.

Input parameters:

- `activity_id` (integer, required): Garmin activity ID from garmin_list_activities
- `ftp_w` (integer): Functional threshold power in watts, for power zones, IF and TSS
- `response_format` (string): 'markdown' for readable text (default), 'json' for complete structured data

### `garmin_training_summary` (~310 tokens)

Training summary

Summarize training per week or month: sessions, hours, distance, elevation and training load, per sport; intensity distribution (share of time in low = HR zones 1–2, moderate = zone 3, high = zones 4–5, with a rough pattern: polarized, pyramidal, threshold-heavy); and the load trend at the end of each period: fitness (CTL, 42-day), fatigue (ATL, 7-day), form (TSB = CTL − ATL) and the acute:chronic ratio (ACWR; above ~1.5 is a commonly cited risk zone).

Load is Garmin's training load per activity; activities without it (older devices, some third-party uploads) get an estimate from average heart rate (Banister TRIMP) scaled to Garmin's load using the user's own activities. The response says how much is estimated. Multisport legs count toward their sport; walking is included as its own sport.

Defaults to the last 12 weeks by week. Filter with sport (e.g. running, cycling, or a type like virtual_ride).

Input parameters:

- `end_date` (string): Defaults to today
- `group_by` (string)
- `response_format` (string): 'markdown' for readable text (default), 'json' for complete structured data
- `sport` (string): Only this sport (parent type) or activity type
- `start_date` (string): Local calendar date, yyyy-MM-dd

### `garmin_recovery_trends` (~200 tokens)

Recovery trends

Relate training load to recovery markers, day by day: resting HR, overnight HRV, sleep score and duration, Body Battery max and stress, each against the user's own rolling 28-day baseline.

Returns: a status (last 7 days vs the previous 28: HRV, resting HR, sleep, load; plus current fitness/fatigue/form), days flagged for low HRV, elevated resting HR or poor sleep, weekly averages, and correlations such as "previous day's load vs next morning's HRV" with their strength. Correlation is not causation, and short periods give noisy results.

Defaults to the last 8 weeks; at most 180 days.

Input parameters:

- `end_date` (string): Defaults to today
- `response_format` (string): 'markdown' for readable text (default), 'json' for complete structured data
- `start_date` (string): Local calendar date, yyyy-MM-dd

### `garmin_compare_activities` (~185 tokens)

Compare activities

Compare 2–6 activities side by side: date, type, duration, distance, pace/speed, heart rate, power (avg/NP), elevation, training effect and load, cadence, and efficiency factor (speed or NP per heartbeat; higher means more output for the same heart rate, a classic way to track aerobic progress on similar sessions).

With deep=true, also analyzes each one's FIT data (downloads files if needed): aerobic decoupling, time in low/moderate/high HR zones and best efforts.

Example: "Am I getting fitter on my Tuesday interval run?" → list those runs, then compare them.

Input parameters:

- `activity_ids` (array, required)
- `deep` (boolean): Also run FIT-based analysis for each activity
- `response_format` (string): 'markdown' for readable text (default), 'json' for complete structured data

### `garmin_query` (~716 tokens)

Query the Garmin cache with SQL

Run one read-only SQLite query against the local Garmin cache, for analyses the other tools don't cover (custom aggregations, correlations, records, comparisons across years).

Views (one row per item; use these first):
\- activities(id, parent_id, is_multisport_parent, type_key, sport, name, start_local, start_date, duration_s, moving_s, distance_m, elevation_gain_m, avg_speed_mps, avg_hr, max_hr, avg_power_w, norm_power_w, calories, aerobic_te, anaerobic_te, training_load, tss, vo2max)
  sport = Garmin parent type (running, cycling, swimming, walking, ...); type_key = exact type (road_biking, virtual_ride, lap_swimming, ...). Multisport: parent rows have is_multisport_parent=1, legs have parent_id; to count volume use is_multisport_parent = 0.
\- daily(date, steps, step_goal, walk_distance_m, floors_up, resting_hr, min_hr, max_hr, stress_avg, stress_max, stress_rest_pct, stress_low_pct, stress_medium_pct, stress_high_pct, body_battery_min, body_battery_max, body_battery_charged, body_battery_drained, intensity_moderate_min, intensity_vigorous_min, calories_total, calories_active, respiration_avg, hydration_ml)
\- sleep(date, start_local, end_local, sleep_s, deep_s, light_s, rem_s, awake_s, nap_s, score, quality, feedback, awake_count, respiration_avg, sleep_stress_avg)  -- date = the morning you woke up
\- hrv(date, last_night_avg, last_night_5min_high, weekly_avg, baseline_low, baseline_high, status)
\- weight(date, weight_kg, bmi, body_fat_pct, body_water_pct, muscle_mass_kg, bone_mass_kg, visceral_fat, source, entries)
Raw JSON (for fields not in the views, via json_extract):
\- activity(id, ..., raw_json)  -- Garmin's full activity summary, e.g. json_extract(raw_json, '$.maxAvgPower_1200'), '$.hrTimeInZone_2', '$.fastestSplit_5000', '$.avgStrideLength'
\- daily_raw(domain, date, json)  -- domains: daily_summaries, sleep, hrv, weight, body_battery, hrv_readings, heart_rate, spo2, food_logs
Dates are 'yyyy-MM-dd' text in the user's local calendar; durations in seconds…

Input parameters:

- `max_rows` (integer)
- `response_format` (string)
- `sql` (string, required): A single SELECT or WITH query

### `garmin_sync` (~292 tokens)

Sync Garmin data

Start downloading Garmin data into the local cache. Runs in the background and returns immediately; follow progress with garmin_sync_status.

You rarely need this: other tools sync automatically on first use and when the cache is over an hour old. Use it to:
  \- fetch the latest data right now (e.g. "I just finished a run"),
  \- extend history further back (from="2019-01-01"),
  \- re-download everything (mode="full"), e.g. after editing many activities in Garmin Connect.

Domains (default: all except fit_files): activities, daily_summaries, sleep, hrv, weight, body_battery, hrv_readings, heart_rate, spo2.
"fit_files" downloads the original FIT file of every activity (one request each, ~2 activities/s). That's optional: FIT files are otherwise fetched on demand by garmin_get_activity_laps and garmin_get_activity_streams.

Input parameters:

- `domains` (array): Only sync these domains. Defaults to all except "fit_files".
- `from` (string): Extend history back to this date (yyyy-MM-dd). History starts at your first activity by default; an earlier date fetches older wellness data. A later date has no effect: history is never narrowed.
- `mode` (string): auto: new data plus any history still missing. full: forget what's cached and re-download.

### `garmin_sync_status` (~88 tokens)

Garmin sync status

Show what's in the local Garmin cache and the progress of the current or last sync.

Returns: the running/last sync (progress, errors), and per data domain the date range covered, number of days, whether all history is in, and the last successful sync.

Input parameters:

- `response_format` (string): 'markdown' for readable text (default), 'json' for complete structured data

## Diagnostics

Captured diagnostic sections: Provenance, Dependencies. The full working is on the page: https://verifymcp.io/servers/app-durely-garmin-insights-mcp/durely-garmin-insights-mcp#diagnostics

## Score history

- 2026-11-05: 81
- 2026-11-04: 81
- 2026-11-03: 81
- 2026-11-02: 81
- 2026-11-01: 81
- 2026-10-31: 81
- 2026-10-30: 81
- 2026-10-29: 66

## Common questions

### What is the durely insights MCP for Garmin server?

durely insights MCP for Garmin is listed in the public MCP registry as app.durely/garmin-insights-mcp. Your full Garmin history, kept locally, analysed down to the second, via the official Personal API. This page covers its npm package (@durely/garmin-insights-mcp).

### Is the durely insights MCP for Garmin server safe to use?

durely insights MCP for Garmin scores 81 out of 100 on VerifyMCP. We found no known CVEs affecting it as of 5 November 2026. It declares no install or post-install scripts. Its build provenance is signed and verified. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm.

### What tools does the durely insights MCP for Garmin server expose?

durely insights MCP for Garmin exposes 21 tools: garmin_status, garmin_get_profile, garmin_list_activities, garmin_get_activity, garmin_get_activity_laps, and 16 more. Their descriptions and schemas cost roughly 5,127 tokens of context every time the server is loaded.

### Is the durely insights MCP for Garmin server still maintained?

durely insights MCP for Garmin is still listed as active in the MCP registry. We last reached this channel on 5 November 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.

### What licence is the durely insights MCP for Garmin server under?

durely insights MCP for Garmin declares the Apache-2.0 licence, which is OSI-approved. That covers the source only, and says nothing about the cost of any service it calls.

### What did VerifyMCP test on the durely insights MCP for Garmin server?

VerifyMCP ran 15 checks on durely insights MCP for Garmin, covering Malware scan, Known CVEs, Install scripts, Dependency health and 11 more. One item could not be completed, a gap on our side rather than a finding about durely insights MCP for Garmin: Stability. One category scores 0 for that reason, because we only credit what we can confirm. Endpoint Security and Transport & Reachability do not apply to an npm package, so they were not tested. The score does not measure everything, and the scoring documentation lists what it leaves out.

## Links

- npm package: https://www.npmjs.com/package/@durely/garmin-insights-mcp
- Socket report: https://socket.dev/npm/package/@durely/garmin-insights-mcp
- Repository: https://github.com/durely/garmin-insights-mcp
- Changelog RSS feed: https://verifymcp.io/servers/app-durely-garmin-insights-mcp/durely-garmin-insights-mcp.xml
- Changelog JSON feed: https://verifymcp.io/servers/app-durely-garmin-insights-mcp/durely-garmin-insights-mcp/changelog.json
- Trust report (JSON): https://verifymcp.io/servers/app-durely-garmin-insights-mcp/durely-garmin-insights-mcp.json
- HTML version of this page: https://verifymcp.io/servers/app-durely-garmin-insights-mcp/durely-garmin-insights-mcp