Provides tools for accessing athlete profile, stats, activities, activity details, zones, and segment effort streams via the Strava API.
Click on "Install 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., "@mcp-strava How was my training this week?"
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.
Minimalist Strava integration for Claude.
7 focused tools. One-time auth. Zero bloat.
"How was my training this week vs last?"
"What's my average heart rate on tempo runs?"
"Break down yesterday's workout by zones"
Related MCP server: Strava MCP Server
Tool | What it does |
| Your profile info |
| Totals: recent, YTD, all-time |
| HR and power zone configuration |
| Browse with date filtering |
| Full workout breakdown with laps and segments |
| Zone distribution with time and percentage per zone |
| Segment analysis with historical comparison |
1. Create Strava App → strava.com/settings/api → get Client ID + Secret
2. Authorize (one-time) → STRAVA_CLIENT_ID=xxx STRAVA_CLIENT_SECRET=xxx \
STRAVA_REDIRECT_URI=http://localhost:3000/auth/callback \
npx mcp-strava-auth
3. Configure Claude → Add to claude_desktop_config.json (see below)
4. Restart Claude → Done! Ask Claude about your workoutsVisit https://www.strava.com/settings/api and create an application to get your Client ID and Secret.
Run the auth server with your Strava credentials:
STRAVA_CLIENT_ID=your_client_id STRAVA_CLIENT_SECRET=your_client_secret STRAVA_REDIRECT_URI=http://localhost:3000/auth/callback npx mcp-strava-authThen:
Visit http://localhost:3000/auth/strava in your browser
Authorize on Strava's page
You'll see "Authorization Successful!" when complete
The server shuts down automatically
Tokens and credentials are stored securely in ~/.strava-mcp/tokens.json.
Add to your Claude Desktop config (claude_desktop_config.json):
macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
open ~/Library/Application\ Support/Claude/Windows: %APPDATA%\Claude\claude_desktop_config.json
{
"mcpServers": {
"strava": {
"command": "npx",
"args": ["-y", "mcp-strava"]
}
}
}Restart Claude Desktop to load the MCP server.
If you prefer to clone and build locally:
Visit https://www.strava.com/settings/api and create an application to get your Client ID and Secret.
git clone https://github.com/adrienlupo/mcp-strava.git
cd mcp-strava
npm install
npm run buildRun the authorization server with your Strava credentials:
STRAVA_CLIENT_ID=your_client_id STRAVA_CLIENT_SECRET=your_client_secret STRAVA_REDIRECT_URI=http://localhost:3000/auth/callback npm run authThen:
Visit http://localhost:3000/auth/strava in your browser
Authorize on Strava's page
You'll see "Authorization Successful!" when complete
The server shuts down automatically
Add to your Claude Desktop config (claude_desktop_config.json):
macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
open ~/Library/Application\ Support/Claude/Windows: %APPDATA%\Claude\claude_desktop_config.json
{
"mcpServers": {
"strava": {
"command": "node",
"args": ["/absolute/path/to/mcp-strava/dist/index.js"]
}
}
}Restart Claude Desktop to load the MCP server.
npm install
npm run build
npm startMIT
Get activity metadata by ID. Returns: name, description, splits, laps, segment_efforts, gear, calories. segment_efforts contains Strava segments from THIS activity only (no historical data). For segment analysis over time, pass segment_efforts[].id to get_segment_effort_streams. For full activity time-series, use get_activity_streams.
| Name | Required | Description | Default |
|---|---|---|---|
| activity_id | Yes | The unique Strava activity ID to retrieve details for. Find this ID by first calling list_activities, or from a Strava URL (e.g., strava.com/activities/12345678 -> activity_id=12345678). Returns comprehensive data: splits, laps, segments, gear, and calories. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Description discloses that segment_efforts contain only current activity segments, and mentions returns. No annotations provided, so description carries burden; it does well but could state read-only nature explicitly.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Description is concise and front-loaded with purpose and return list. Every sentence adds value, though slightly more brevity could be achieved.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema, description lists return fields, references sibling tools, and covers usage context fully. Provides enough information for an AI agent to understand and use the tool correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema covers activity_id fully, and description adds value by explaining where to find the ID and linking to list_activities. Schema coverage is 100%, so description adds useful extra context.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Clearly states 'Get activity metadata by ID' and lists specific return fields, distinguishing from sibling tools like get_activity_streams and get_segment_effort_streams.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly guides when to use this tool vs. alternatives: 'For segment analysis over time...use get_segment_effort_streams', 'For full activity time-series, use get_activity_streams'.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get zone distribution for an activity (heart rate, pace, power). Returns zone boundaries, time in seconds, and percentage per zone. For activity-specific zone analysis with time/ratios.
| Name | Required | Description | Default |
|---|---|---|---|
| activity_id | Yes | The Strava activity ID |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden for behavioral traits. It does not disclose any side effects, permissions, rate limits, or data availability constraints. For a read-only tool, it should at least indicate it's a safe query.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, each carrying essential information. The purpose is front-loaded, and no redundant or extraneous content exists.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the one-parameter input and no output schema, the description adequately explains the return values (zone boundaries, time, percentage) and the use case (activity-specific zone analysis). Minor omission: no mention that zones may not exist for all activities.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% with a clear description of activity_id. The description reinforces that the parameter identifies the activity but adds no new semantic details beyond what the schema already provides.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly specifies the tool's action (get zone distribution), the resource (activity), and the types (heart rate, pace, power). It also lists the return values (zone boundaries, time in seconds, percentage). This distinguishes it from siblings like get_athlete_zones.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description only states what the tool does, with no guidance on when to use it versus alternatives, when not to use it, or prerequisites. Sibling tools like get_athlete_zones might be related but are not mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get authenticated athlete's Strava profile. Returns: name, username, bio, location, weight, premium status, measurement preferences.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full burden. It accurately describes the read-only nature and return fields but could explicitly state authentication requirement. No contradiction.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Single sentence plus bullet list of return fields, perfectly concise and front-loaded with no redundant text.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a zero-parameter tool with no output schema, the description fully covers purpose and return data, making it complete for agent use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
No parameters in schema, so baseline is 4. Description adds no parameter info (none needed). Schema coverage is 100% trivially.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states 'Get authenticated athlete's Strava profile' and lists returned fields (name, username, bio, etc.), distinguishing it from siblings like get_athlete_stats which return different data.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for profile retrieval but gives no explicit guidance on when to use vs alternative tools like get_athlete_stats, nor does it mention exclusions or prerequisites.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get aggregated activity statistics by sport type. Returns: recent (4 weeks), YTD, all-time totals for ride/run/swim. Each: count, distance (m), moving_time (s), elevation_gain (m).
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full burden. It discloses the return structure (time periods, sports, units) and implies a read-only operation. However, it does not mention authentication requirements or rate limits, which are common but not critical for this simple retrieval.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence followed by a bullet list of return fields. It is front-loaded with the purpose, uses clear units, and contains no redundant information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Despite lacking an output schema, the description fully explains return values: time ranges, sports, metrics, and units. It covers everything an agent needs to interpret the response correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has zero parameters, so schema description coverage is 100%. The description adds no parameter info but clarifies the output structure in detail, which is sufficient given no parameters exist.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'Get' and resource 'aggregated activity statistics', specifies sports (ride/run/swim), time periods (recent 4 weeks, YTD, all-time), and metrics (count, distance, moving_time, elevation_gain). This distinguishes it from siblings like get_activity_detail or list_activities.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for aggregated stats but does not explicitly state when to use this tool versus alternatives like get_activity_detail (individual activity) or get_athlete_profile (profile info). No exclusions or when-not-to-use guidance are provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get athlete's configured HR and power zones from Strava. Returns: heart_rate.zones[], power.zones[] with min/max for each zone. Requires profile:read_all scope.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden. It discloses the return format and required scope, but does not explicitly state that the operation is read-only or non-destructive, nor does it mention any potential side effects, rate limits, or caching behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences long, efficient, and front-loaded with the core purpose first, followed by return structure and scope requirement. No redundant information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema, the description adequately explains the return structure (zones with min/max). It also covers the required scope. For a simple zero-parameter tool, it is fairly complete, though it lacks details on potential edge cases like missing zones.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
There are zero parameters and schema coverage is 100% vacuously. The description adds no parameter information because none is needed. Baseline score of 4 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses the clear verb 'Get' and identifies the resource as 'athlete's configured HR and power zones'. It also specifies the return structure with heart_rate.zones[] and power.zones[]. This is specific but does not differentiate from the sibling tool get_activity_zones.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description mentions the required scope 'profile:read_all', which is a usage condition, but it provides no guidance on when to use this tool versus alternatives like get_activity_zones, nor does it specify when not to use it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Analyze a Strava segment with full historical comparison. ONE call returns EVERYTHING: segment info, current effort stats, AND comparison with ALL previous attempts (best_time, average_time, total_efforts, rank, previous_efforts list). No need to list_activities - this tool automatically fetches all historical data. Use when user asks about segment history, progress, PRs, or performance over time. Input: segment_effort_id from get_activity_detail's segment_efforts array.
| Name | Required | Description | Default |
|---|---|---|---|
| segment_effort_id | Yes | The Strava segment effort ID as a string (to preserve precision for large IDs). Get this from get_activity_detail response which includes segment_efforts array. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It discloses that one call returns everything and automatically fetches all historical data, but does not mention potential side effects like rate limiting, performance characteristics, or authorization requirements beyond what is implied.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise at two sentences, front-loads the primary function, and includes all necessary details without verbosity. Every sentence adds value.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema and a single parameter, the description comprehensively covers input sourcing, output contents, and usage scenario. It explains that the tool fetches historical data automatically, making it complete for the tool's complexity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema already describes the parameter with high coverage (100%). The description adds value by specifying where to obtain the segment_effort_id (from get_activity_detail's segment_efforts array), providing context beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool analyzes a Strava segment with full historical comparison, specifying it returns segment info, effort stats, and comparison with all previous attempts. It distinguishes itself from list_activities by saying 'No need to list_activities', making the purpose unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit usage context: 'Use when user asks about segment history, progress, PRs, or performance over time.' It also notes that this tool supersedes list_activities for historical data. However, it does not mention when not to use it or list alternative tools for different scenarios.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List activities with filtering and pagination. Returns: id, name, type, sport_type, start_date, distance (m), moving_time (s), elapsed_time (s), total_elevation_gain (m), average_speed (m/s), heartrate, watts. Use week_offset for calendar weeks (0=this week, -1=last week). Monday-Sunday.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | Maximum number of activities to return (1-200, default: 10). For 'recent' or 'last N' queries, set this limit without date filters. Ignored when week_offset is set or both before/after are provided (fetches all in range). | |
| week_offset | No | Get activities from a specific calendar week (Monday-Sunday). 0 = this week, -1 = last week, -2 = two weeks ago, etc. PREFERRED for week-based queries. When set, 'before' and 'after' are ignored. | |
| before | No | ISO date string (e.g., '2024-12-31'). Activities before this date (exclusive). Ignored if week_offset is set. Use for custom date ranges only. | |
| after | No | ISO date string (e.g., '2024-01-01'). Activities after this date. Ignored if week_offset is set. Use for custom date ranges only. | |
| page | No | Page number for pagination (default: 1). Use to access older activities beyond the limit. Example: limit=10, page=2 returns activities 11-20. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided; description carries full burden. It lists returned fields and mentions pagination, but does not explicitly state the operation is read-only or disclose any potential side effects. The absence of behavioral flags is acceptable for a list tool but could be improved.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Three sentences that efficiently convey purpose, return fields, and key usage guidance without redundancy or unnecessary detail.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Lists returned fields which is helpful given no output schema, but does not mention default ordering (e.g., most recent first) or behavior when no activities match. Sibling tools are distinct, so context is adequate but not fully complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, but the description adds valuable context: clarifies week_offset usage, calendar week definition (Monday-Sunday), and when limit is ignored. This enhances understanding beyond the schema descriptions alone.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description succinctly states it lists activities with filtering and pagination and enumerates the returned fields. It does not explicitly differentiate from siblings like get_activity_detail, but the verb 'list' and field list imply this is the main listing tool.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides explicit guidance on using week_offset for calendar weeks and explains parameter interactions (limit ignored when week_offset or both before/after are provided). Lacks explicit alternatives or when-not-to-use scenarios for sibling tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
A simple test tool that verifies the server is running
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden, but it only states the tool verifies the server is running. It does not disclose additional behavioral traits like side effects or response format, though for a ping tool the behavior is simple and largely inferred.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, complete sentence with no unnecessary words. It is front-loaded with the purpose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (no parameters, no output schema, no annotations), the description fully conveys the tool's purpose and behavior, making it complete for its context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
No parameters exist, and schema coverage is 100%. The description adds no parameter information, but with zero parameters there is nothing to add; baseline 4 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool is a test that verifies the server is running, using a specific verb and resource. It distinguishes itself from sibling tools which are data retrieval operations.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description identifies the tool as a simple test tool for verifying server status, which implies when to use it. No alternatives are needed as no sibling tool performs this function.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
v1.0.1get_activity_detailget_activity_zonesget_athlete_profileget_athlete_statsget_athlete_zonesget_segment_effort_streamslist_activitiespingEach tool has a clearly distinct purpose, covering activities, zones, athlete info, segments, and listing. Descriptions provide detailed distinctions, e.g., get_activity_zones vs get_athlete_zones are for activity-specific vs athlete-configured zones.
Almost all tools follow a consistent verb_noun pattern with snake_case (get_*, list_*). 'ping' is a slight outlier but is a common test tool and does not confuse the overall pattern.
8 tools is appropriate for a Strava integration, covering core read operations for activities, athletes, zones, and segments without being overly numerous or sparse.
The tool set covers main read operations, but there is a notable gap: get_activity_detail mentions using get_activity_streams for time-series data, yet that tool is not present. This creates a dead-end for agents. Missing write operations like upload or update activities, but those may be out of scope.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
Garmin data in Claude: 135 tools — activities, sleep, HRV, training, workouts. Free, open source.
Connect Claude to your Intervals.icu watch data for fitness, workout review, and plan writing.
WHOOP recovery, strain, sleep and workouts in Claude via official WHOOP OAuth. Free, open source.
Garmin data in Claude & ChatGPT via the Garmin Health API. OAuth sign-in, no password sharing.
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/adrienlupo/mcp-strava'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
