David Kucher

What Numbers Station Taught Me About My Fitness (That Strava Couldn’t)

I love Strava. It keeps me motivated, helps me track my runs, and gives me a sense of progress. Being in the data industry, I wanted to see my metrics. But after looking into the in-app analytics, I realized I had more questions than Strava could answer.

Strava is nice. Well, it’s OK. 

If you’re not familiar with Strava, it’s a social media platform where athletes can share their workouts, complete exercise challenges, plan exercises, and more. It’s almost perfect—but not quite. As an avid runner and exercise enthusiast, I love the social aspect of the platform: I upload my runs, receive kudos from my followers (which keeps me motivated), and feel inspired by my feed. 

So what’s missing? 

For starters, analytics! I want to answer questions like:

  • How many runs have I recorded? 
  • What’s my average distance? 
  • What activities do I do most? 
  • What day of the week do I exercise the most? 

Strava’s user interface and platform aren’t built for these types of questions. Instead, it only provides a simple set of summary statistics.

To get a deeper understanding of my exercise statistics, I decided to connect my data to Numbers Station.

Getting Started with Numbers Station

I wrote a quick script to download all my Strava activities. 

from pathlib import Path
from typing import Any
import click
import pandas as pd
import requests
from requests import Session
# Strava API endpoints
OAUTH_BASE_URL = "https://www.strava.com/oauth"
TOKEN_URL = f"{OAUTH_BASE_URL}/token"
AUTH_URL = f"{OAUTH_BASE_URL}/authorize"
BASE_URL = "https://www.strava.com/api/v3"
CALLBACK_DOMAIN = "http://localhost"
def create_session(client_id: str, client_secret: str, refresh_token: str) -> Session:
"""Create a session with the Strava API."""
response = requests.post(
TOKEN_URL,
data={
"client_id": client_id,
"client_secret": client_secret,
"refresh_token": refresh_token,
"grant_type": "refresh_token",
},
)
try:
access_token = response.json()["access_token"]
session = Session()
session.headers.update({"Authorization": f"Bearer {access_token}"})
return session
except KeyError as e:
raise RuntimeError(f"Error refreshing token: {response.text}") from e
def create_scoped_session(client_id: str, client_secret: str) -> Session:
"""Create a scoped session with the Strava API."""
res = requests.get(
AUTH_URL,
params={
"client_id": client_id,
"redirect_uri": CALLBACK_DOMAIN,
"scope": ["activity:read_all"],
"response_type": "code",
},
)
url = res.history[0].url if res.history else res.url
code = input(
f"VISIT THIS URL, LOG IN, AND GRANT ACCESS: {url}Enter code from redirected URL: "
)
response = requests.post(
TOKEN_URL,
data={
"client_id": client_id,
"client_secret": client_secret,
"code": code,
"grant_type": "authorization_code",
},
)
access_token = response.json()["access_token"]
session = Session()
session.headers.update({"Authorization": f"Bearer {access_token}"})
return session
def get_all_activities(scoped_session: Session) -> list[dict[str, Any]]:
"""Fetch all activities from Strava API."""
activities = []
page = 1
print("Fetching activities…")
while True:
response = scoped_session.get(
f"{BASE_URL}/athlete/activities", params={"page": page, "per_page": 50}
)
if response.status_code != 200:
print(f"Error fetching activities: {response.text}")
break
data = response.json()
if not data:
break
activities.extend(data)
print(f"Fetched {len(data)} activities. Total: {len(activities)}", end="\r")
page += 1
print(f"Fetched all activities. Total: {len(activities)}.")
return activities
def get_athelete(session: Session) -> dict[str, Any]:
"""Get athlete from Strava API."""
athlete_res = session.get(f"{BASE_URL}/athlete")
if athlete_res.status_code != 200:
raise ValueError(f"Error fetching athlete: {athlete_res.text}")
return athlete_res.json()
@click.command()
@click.argument("client-id", type=str)
@click.argument("client-secret", type=str)
@click.option("–output-file", type=str, default="activities.csv")
def get_activities(client_id: str, client_secret: str, output_file: str) -> None:
"""Get activities from Strava API."""
scoped_session = create_scoped_session(client_id, client_secret)
activities = get_all_activities(scoped_session)
output_path = Path(output_file).with_suffix(".csv")
if not output_path.is_relative_to("."):
output_path.parent.mkdir(parents=True, exist_ok=True)
df = pd.DataFrame(activities)
# Pop unnecessary columns (e.g. structured data or columns with only null values)
df.drop(
columns=[
"resource_state",
"athlete",
"location_city",
"map",
"location_city",
"location_state",
"location_country",
"start_latlng",
"end_latlng",
"heartrate_opt_out",
"display_hide_heartrate_option",
"upload_id",
"upload_id_str",
"total_photo_count",
],
inplace=True,
)
df.to_csv(output_path, index=False)
print("Saved activities to:", str(output_path))
if __name__ == "__main__":
get_activities()
view raw download_strava_activities.py hosted with ❤ by GitHub

Next, I uploaded all these activities to Numbers Station.

In just a few moments, Numbers Station created a new dataset for me, linking it with my uploaded data. This dataset provides an overview of my workout history and lets me ask ad-hoc questions, with answers computed on-the-fly to give me real-time insights.

Exploring my data

Strava’s app offers a few summary statistics, but I wanted to dig deeper into my exercise habits.

Let’s start with the basics. I love to run—but how much? Let’s see if I can get my lifetime miles.

In Strava, I found this by clicking on Profile > Statistics > then scrolling down to my all-time stats. I forgot how to do this, so it took me a couple of minutes to track it down.

That’s a lot! Now, let’s see if I can verify this data in Numbers Station to ensure everything is uploaded correctly.

It adds up! With a simple question in natural language, I can get the information I need, on-demand. Now, let’s see if I can break this down by activity, since I run both on the road and on trails.

Nice! Turns out, I’ve run ~2,881 miles—enough to go coast to coast across the entire country!

Now, let’s go even deeper. I’d like to see:

  • Which sports/activities do I do most?
  • Which days do I tend to exercise the most?

First let’s ask for a chart of my activities by frequency.

Numbers Station’s Charting Agent made the chart, but I want to add some labels to make this easier to read.

Much better. I’m thrilled! Seeing all my activities in one place is exciting—I had no idea I’m approaching 500 recorded runs.

Let’s see if I can analyze my weekly exercise patterns, and whether I can get some recommendations on how to train smarter.

Insights and Next Steps

Fortunately, Numbers Station’s analytics agents know the difference between crunching numbers and giving exercise advice. Numbers Station has built-in guard rails to ensure that we use the power of LLMs to run analysis and answer your data questions—so you can make more informed decisions instead of getting AI-generated fitness tips. 

By simply uploading a CSV into Numbers Station, I’ve learned that I exercise most on Wednesdays and Saturdays, and that I strongly prefer running over other activities. To spread out the load on my knees, I might start incorporating more yoga and swimming so I can still push my cardiovascular endurance without injuring myself.

Thanks to Numbers Station’s ad-hoc query capabilities, I now have a clearer picture of where I am in my fitness journey. In just a few minutes, I was able to uncover valuable insights using plain English—something I was never able to do with my Strava profile alone!

If you’re interested in instantly analyzing your data with natural language queries, contact us —we’d love to help you get started!

You May Also Like