Skip to main content
Glama
r-huijts

Strava MCP Server

by r-huijts

get-activity-streams

Retrieve detailed time-series data from Strava activities for analyzing workout metrics, visualizing routes, and performing activity analysis with flexible resolution and format options.

Instructions

Retrieves detailed time-series data streams from a Strava activity. Perfect for analyzing workout metrics, visualizing routes, or performing detailed activity analysis.

Key Features:

  1. Multiple Data Types: Access various metrics like heart rate, power, speed, GPS coordinates, etc.

  2. Flexible Resolution: Choose data density from low (~100 points) to high (~10000 points)

  3. Smart Pagination: Get data in manageable chunks optimized for LLM context limits

  4. Rich Statistics: Includes min/max/avg for numeric streams

  5. Dual Format Support: Compact (LLM-optimized) or verbose (human-readable)

  6. Intelligent Downsampling: Automatically reduce large datasets while preserving key features

Format Options:

  • compact (default): Raw arrays, minified JSON, ~70-80% smaller payloads, ideal for LLM processing

  • verbose: Human-readable objects with formatted values, backward compatible with legacy format

Common Use Cases:

  • Analyzing workout intensity through heart rate zones

  • Calculating power metrics for cycling activities

  • Visualizing route data using GPS coordinates

  • Analyzing pace and elevation changes

  • Detailed segment analysis

Output Format:

  1. Metadata: Activity overview, available streams, data points, units, format info

  2. Statistics: Summary stats for each stream type (max/min/avg where applicable)

  3. Data: Time-series data in compact arrays or verbose objects (based on format parameter)

Notes:

  • Requires activity:read scope

  • Not all streams are available for all activities

  • Older activities might have limited data

  • Large activities are automatically chunked to ~50KB per message

  • Use max_points parameter to downsample very large activities intelligently

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
idYesThe Strava activity identifier to fetch streams for. This can be obtained from activity URLs or the get-activities tool.
typesNoArray of stream types to fetch. Available types: - time: Time in seconds from start - distance: Distance in meters from start - latlng: Array of [latitude, longitude] pairs - altitude: Elevation in meters - velocity_smooth: Smoothed speed in meters/second - heartrate: Heart rate in beats per minute - cadence: Cadence in revolutions per minute - watts: Power output in watts - temp: Temperature in Celsius - moving: Boolean indicating if moving - grade_smooth: Road grade as percentage
resolutionNoOptional data resolution. Affects number of data points returned: - low: ~100 points - medium: ~1000 points - high: ~10000 points Default varies based on activity length.
series_typeNoOptional base series type for the streams: - time: Data points are indexed by time (seconds from start) - distance: Data points are indexed by distance (meters from start) Useful for comparing different activities or analyzing specific segments.distance
pageNoOptional page number for paginated results. Use with points_per_page to retrieve specific data ranges. Example: page=2 with points_per_page=100 gets points 101-200.
points_per_pageNoOptional number of data points per page. Special values: - Positive number: Returns that many points per page - -1: Returns ALL data points split into multiple messages (~1000 points each) Use -1 when you need the complete activity data for analysis.
formatNoOutput format: - compact: Raw arrays, minified JSON (~70-80% smaller, LLM-friendly) - verbose: Human-readable objects with formatted values (backward compatible)compact
max_pointsNoMaximum number of data points to return. If activity exceeds this, data will be intelligently downsampled while preserving peaks and valleys. Useful for very large activities.
Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries full burden and excels by disclosing key behavioral traits: it requires 'activity:read scope', notes 'not all streams are available for all activities', warns 'older activities might have limited data', explains 'large activities are automatically chunked to ~50KB per message', and describes intelligent downsampling for large datasets. This covers permissions, data availability, limitations, and performance considerations thoroughly.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is well-structured with sections like 'Key Features', 'Format Options', 'Common Use Cases', 'Output Format', and 'Notes', making it easy to scan. However, it is lengthy with multiple bullet points and detailed explanations, which, while informative, could be more concise. Every sentence adds value, but some redundancy exists (e.g., repeating format details).

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the complexity of 8 parameters, no annotations, and no output schema, the description is highly complete. It covers purpose, usage, behavioral traits, parameter semantics, output format details, and limitations. The 'Output Format' section compensates for the lack of output schema by describing metadata, statistics, and data structure, making it sufficient for an agent to understand what to expect.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The schema description coverage is 100%, so the baseline is 3. The description adds significant value by explaining parameter implications beyond the schema: it details how 'resolution' affects data points (~100 to ~10000), describes 'smart pagination' for 'page' and 'points_per_page', explains 'intelligent downsampling' for 'max_points', and elaborates on 'format' options (compact vs verbose) with payload size impacts. This enhances understanding but doesn't fully cover all 8 parameters in depth.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool 'retrieves detailed time-series data streams from a Strava activity' with specific verbs ('retrieves', 'analyzing', 'visualizing') and resources ('Strava activity', 'workout metrics', 'routes'). It distinguishes from siblings like get-activity-details (which likely provides summary info) and get-activity-laps (which focuses on lap segments) by emphasizing time-series data streams for analysis.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description explicitly states when to use this tool: 'Perfect for analyzing workout metrics, visualizing routes, or performing detailed activity analysis' and lists common use cases like analyzing heart rate zones, calculating power metrics, and visualizing GPS coordinates. It distinguishes from siblings by focusing on time-series data streams rather than summary details, photos, or segments.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Install Server

Other Tools

Latest Blog Posts

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/r-huijts/strava-mcp'

If you have feedback or need assistance with the MCP directory API, please join our Discord server