Then, a few weeks ago, I discovered that Strava has a well-documented API that lets you programmatically access all your data and activities.

Around the same time, I had started using Claude Desktop more and more for personal productivity. For example, checking my emails using the Gmail connector, asking it to suggest what I should unsubscribe from. The experience of having Claude help manage my inbox was eye-opening. Instead of manually sifting through hundreds of emails, I could just ask: "What newsletters am I subscribed to that I haven't opened in months?"

That's when the idea hit me: What if I could do the same thing with my Strava data? What if I could ask Claude about my runs and progress, and have it analyze my training patterns just like it helps me manage my inbox?

So I decided to build a Strava connector for Claude Desktop. Here's how it went, what I learned, and how you can use it too.

The Spark: Bringing AI to Running Data

The power of Claude Desktop's MCP (Model Context Protocol) connectors is that they turn AI into a personalized assistant that actually knows your data. With the Gmail connector, Claude doesn't just know about email; it knows my emails. It can give me specific, actionable insights.

I wanted that same experience for my running data. I wanted to simply ask: "How's my running been this month compared to last?" and get an intelligent analysis.

What is MCP (Model Context Protocol)?

The Model Context Protocol is a standard created by Anthropic that allows AI assistants like Claude to connect to external data sources and tools. Think of it as a bridge between Claude and the rest of your digital world.

With MCP, you can:

• Give Claude access to your data (like Strava activities, Google Drive files, or databases)

• Let Claude perform actions on your behalf (create tasks, send emails, etc.)

• Build custom integrations

The Technical Architecture

My Strava MCP server is built with Node.js and TypeScript, implementing the MCP specification to provide five main tools:

1. get_recent_activities - Your activity feed

// Example: Get your 10 most recent runs
{
  "limit": 10,
  "activity_type": "Run"
}

2. get_activity_details- Deep dive into a specific workout

// Get detailed stats for a specific activity
{
  "activity_id": "123456789"
}

3. get_athlete_profile- Your basic profile info

// Get profile information, stats, and gear
{}

4. get_monthly_statat-Aggregate monthly performance

// Get comprehensive stats for a specific month
{
  "year": 2025,
  "month": 12
}

5. get_activites_by_date_range- custom time periods

// Query activities within a specific date range
{
  "start_date": "2026-01-01",
  "end_date": "2026-01-31"
}

All data is returned in metric units (km, m, km/h, min/km pace) because, well, I'm European and that's what makes sense to me!

The OAuth Challenge (And How I Solved It)

The biggest technical hurdle wasn't the MCP implementation. It was handling Strava's OAuth authentication flow properly. Strava's API tokens expire after 6 hours and require periodic refresh.

The limitation: Unlike first-party connectors like Gmail, custom MCP servers in Claude Desktop can't use popup authentication flows. There's no "Connect to Strava" button like you'd see with official integrations (or at least I havn't found a way for now).

My solution: A one-time setup script that gets your initial tokens, then automatic refresh handling after that.

On first run, you execute a simple OAuth flow script that gets your tokens. After that initial setup, the server handles everything automatically. It checks if the token expiration is expired and refreshed it if needed. Once it's running, you never think about authentication again.

async function ensureValidToken(): Promise<string> {
  const tokens = loadTokens();
  
  // Check if token is expired or about to expire (within 5 minutes)
  const expiresAt = tokens.expires_at || 0;
  const now = Math.floor(Date.now() / 1000);
  
  if (expiresAt - now < 300) {
    // Token expired or expiring soon - refresh it
    const newTokens = await refreshAccessToken(tokens.refresh_token);
    saveTokens(newTokens);
    return newTokens.access_token;
  }
  
  return tokens.access_token;
}

The key: proactive refresh (5-minute buffer before expiration) and persistent storage so tokens survive server restarts.

Real-World Usage Examples

Quick check-ins:

• "How was my latest run?"

• "What activities did I do this week?"

Performance analysis:

• "What's my average pace this month compared to last month?"

• "How many kilometers have I run this week?"

Trend spotting:

• "Give me stats for December 2025"

• "Show me my hearth rate progression in 2025"

Claude processes the data and provides conversational, insightful responses.

The tool in action

Try It Yourself

Want to use this with your own Strava data? Here's the quick setup:

The code is open source and available on GitHub: github.com/szoboszlaianna/strava_connector

Prerequisites

1. Create a Strava API application at https://www.strava.com/settings/api

2. Note your Client ID and Client Secret

Installation

# Clone the repo
git clone https://github.com/szoboszlaianna/strava_connector.git
cd strava_connector

# Install dependencies
npm install

# Set up environment variables
cp .env.template .env
# Edit .env with your Client ID and Secret

# Build the project
npm run build

OAuth Setup (One-time)

# Start OAuth flow
npm run oauth-setup

# Follow the instructions:
# 1. Open the provided URL in your browser
# 2. Authorize the application
# 3. Copy the authorization code from the redirect URL
# 4. Run: npm run oauth-setup YOUR_CODE

# Add the returned tokens to your .env file

Configure Claude Desktop

Add to your claude_desktop_config.json:

{
  "mcpServers": {
    "strava": {
      "command": "node",
      "args": ["/path/to/strava_connector/build/index.js"],
      "env": {
        "STRAVA_CLIENT_ID": "your_client_id",
        "STRAVA_CLIENT_SECRET": "your_client_secret",
        "STRAVA_ACCESS_TOKEN": "your_access_token",
        "STRAVA_REFRESH_TOKEN": "your_refresh_token"
      }
    }
  }
}

Restart Claude Desktop, and you're ready to go!

What's Next?

This project is just getting started. Here are features I'm considering:

• Training insights: Detect patterns like overtraining or improvement trends

• Goal tracking: Set monthly distance/time goals and track progress

• Activity recommendations: Suggest workout types based on recent training

• Weather correlation: Cross-reference activities with weather data

• Comparative analysis: Compare current performance to previous periods (This already works by fetching data for each month, but I am considering adding it's own tool)

• Add skills to Claude: Enhance the tool and streamline visualization with custom Claude skills. Right now it is sometimes showing me diagrams, sometimes give me written text, I would like to make sure that the output I get is consistent.