Connecting WHOOP with Claude, and Google Calendar
The most powerful personal health stack that interprets your health data.
I had a brutal Tuesday two weeks ago. I was running on five hours of sleep, back-to-back meetings starting at 8am, a critical design review at 2pm, and I had somehow convinced myself to schedule a strength session at 6pm because “I’d feel better after.” I did not feel better after. I felt like a hollowed-out version of myself for the rest of the week.
Here’s the thing — I had the data to know that was going to happen. My WHOOP was telling me my HRV had cratered overnight. My recovery score was in the red. My calendar was packed with high-cognitive-load events. But none of those systems were talking to each other. I was the one who had to synthesize it all in real time, which I did not do, because I was already tired.
That moment of friction, the gap between having data and having insight — is exactly what a new class of AI integrations is starting to close.
The Trend: Wearables Are Leaving Their Walled Gardens
For most of its existence, WHOOP was a closed loop. Your data lived in the app, you looked at your recovery score in the morning, maybe you adjusted your training. It was useful in a passive, dashboard-ish way. You had to go find the insight. The insight didn’t come to you.
That’s changing fast.
In May 2026, WHOOP announced a major expansion of its health platform, including on-demand clinician consultations, Electronic Health Record syncing through HealthEx, and two significant AI features: My Memory (a persistent personal context layer) and Proactive Check-Ins — marking what the company described as its evolution into a full intelligent health platform.
But even before those official features launched, the developer community had already been building something more interesting — and arguably more flexible. Through a handful of open-source Model Context Protocol (MCP) servers, anyone willing to spend 20 minutes on setup can now pipe their WHOOP data directly into Claude, the AI assistant, and get conversational access to their biometrics.
The pitch is simple: connect your WHOOP fitness data to Claude Desktop through the Model Context Protocol and access your workouts, recovery, sleep patterns, and more through natural language queries — with your data staying local and private.
That last part matters. We’ll come back to it.
The Setup: What This Actually Looks Like in Practice
Here’s where it gets concrete. There are currently several WHOOP MCP servers built by the developer community. These expose tools covering recovery scores, HRV, sleep stages, day strain, workout history, and trend analysis over configurable windows — running locally with OAuth2 setup, storing refresh tokens in your home directory, and auto-refreshing on subsequent runs.
You connect that server to Claude Desktop. You also connect Google Calendar via its own MCP connector (which Claude.ai supports natively on Pro plans). Now Claude has simultaneous access to:
Your biometric data from WHOOP (how your body actually performed and recovered)
Your calendar (what you’re asking your body to handle today and this week)
The queries you can now run are qualitatively different from anything a single-app dashboard can give you:
“My recovery score is 42 today. I have a board presentation at 3pm and a dinner with a client at 7pm. Should I move my morning run or keep it light?”
“Look at my sleep data from the last two weeks alongside my calendar density. Is there a pattern between my meeting load on Thursdays and my Friday recovery dips?”
“I have a big product launch week coming up. Based on my historical strain and recovery patterns, what’s my optimal sleep target and the latest I should schedule workouts?”
The use cases that developers are already building around include: daily readiness check-ins that pull last night’s sleep and today’s recovery to summarize what it implies for training intensity and focus; weekly trend reviews aggregating seven days of recovery, HRV, RHR, sleep consistency, and strain to spot improvements, plateaus, or warning signs; and training-load planning using recent strain and recovery patterns to decide when to push, maintain, or deload.
Add calendar context and each of those becomes significantly more actionable. You’re no longer looking at your body in isolation — you’re looking at your body within your life.
How to Set It Up (Mac, ~20 Minutes Total)
If you just want the concept, skip ahead. If you want to actually do this tonight, here’s the exact path.
Phase 1 — Get Your WHOOP Developer Keys (~5 min, browser only)
Go to developer-dashboard.whoop.com and sign in. Create a team if prompted (any name works), then create an app with these settings:
Scopes:
read:profile,read:workout,read:sleep,read:recovery,read:cycles,offlineRedirect URI:
http://localhost:8080/callback
Save. Copy your Client ID and Client Secret somewhere handy — you’ll need them in a moment.
Phase 2 — Set Up the Server (~10 min, Terminal)
Open Terminal (⌘ + Space → type Terminal → Enter). Paste each block in order:
# 1. Download the code
cd ~ && git clone https://github.com/juliandag/whoop-mcp.git && cd whoop-mcp
# 2. Set up Python and install dependencies (takes ~1 min)
python3 -m venv .venv && source .venv/bin/activate && pip install -r requirements.txt
# 3. Create and open your credentials file
cp .env.example .env && open -e .env
# 4. Authenticate with WHOOP
source .venv/bin/activate && python setup.py
In the text file that opens, paste your Client ID and Secret after the = signs on their respective lines. Save and close.
Your browser opens a WHOOP login page. Log in, approve access. Tokens are saved locally — you’re done with Terminal.
Phase 3 — Connect Claude Desktop (~5 min)
Run this to get your exact folder path:
echo $HOME/whoop-mcpCopy the result (e.g. /Users/yourname/whoop-mcp). Then open your Claude Desktop config:
open ~/Library/Application\ Support/Claude/Open claude_desktop_config.json (create it if it doesn’t exist) and paste this, swapping in your actual path:
{
“mcpServers”: {
“whoop”: {
“command”: “/Users/yourname/whoop-mcp/.venv/bin/python”,
“args”: [”/Users/yourname/whoop-mcp/src/whoop_mcp_server.py”],
“env”: {
“PYTHONPATH”: “/Users/yourname/whoop-mcp/src”
}
}
}
}Save. Quit Claude Desktop completely (⌘+Q) and reopen it.
Test it: Type “Show my WHOOP profile” — if your data comes back, you’re live. Then try: “How is my recovery trending this week?”
Why This Matters Beyond the Gym
I want to push past the athlete framing here, because most people I know who wear WHOOP aren’t training for marathons. They’re founders, designers, product managers, engineers — people who do cognitive work for a living and treat the band as a proxy for overall readiness.
And that’s exactly where the calendar integration becomes most interesting. Because the highest-stakes decisions most of us face on a given day aren’t about whether to do a tempo run. They’re about when to schedule a hard conversation, whether to say yes to an extra commitment, how to structure a day before a travel week. These are judgment calls that most of us make on autopilot — powered mostly by coffee and calendar density.
Wearables in 2026 are tracking HRV suppression patterns, since sustained low HRV over multiple days suggests the autonomic nervous system isn’t recovering. Sleep disruption trends also now register as early warning signals, since overtraining — and by extension, overwork — often manifests as poor sleep quality before performance declines.
What if those signals informed your planning before the crash, not after? That’s the shift this integration enables. From reactive to anticipatory.
A Framework for Thinking About Your Personal Health Stack
If you’re a product person, here’s how I’d think about this in terms of information layers:
Layer 1 — Signal (What your body is doing): This is your WHOOP data. HRV, sleep stages, respiratory rate, strain. It’s continuous, objective, and timestamped. This is the raw input.
Layer 2 — Context (What you’re asking your body to do): This is your calendar. Meetings, travel, high-stakes events, social commitments. Most health apps have zero access to this layer, which is why their “recommendations” often feel generic.
Layer 3 — Synthesis (What it means): This is where Claude lives when you connect both. It’s the reasoning layer that takes signal + context and produces an actual recommendation — not a score, not a nudge, but a judgment call with your specific situation accounted for.
The magic isn’t in any single data source. It’s in the synthesis layer having access to both.
The Privacy Question You Should Be Asking
Before you wire everything together, there’s a real conversation to have about data. The local-first WHOOP MCP approach is built specifically for people who care about this: tokens are written locally, not pasted into chat, and your data doesn’t pass through a third-party server.
That’s meaningfully different from handing your health data to a consumer app that might resell it, aggregate it, or use it for model training. The local MCP model keeps your biometrics on your machine and passes them into Claude’s context window only for the duration of a session.
Still — you’re giving an AI model access to your HRV, your sleep, and your calendar. That deserves a pause. Know what you’re sharing and with what. WHOOP’s own “My Memory” feature acknowledges this tension explicitly: members can view, add, edit, or delete personal context at any time, and the company frames it as “your information, and you decide what WHOOP remembers.” Apply that same standard to any third-party integration you build.
What Comes Next
Apple’s Health+ service, reportedly launching in 2026, is framing its AI health coach as something that would offer guidance that “anticipates, not just responds” — sleep hygiene tweaks that match your actual patterns, stress strategies that fit your calendar rhythm, and flags about whether a doctor visit is worth scheduling, grounded in clinical knowledge from Apple’s on-staff physicians.
The direction is clear. The question is whether you wait for one company to build the integrated solution for you, or whether you stitch together the pieces that exist today — trading polish for flexibility and data ownership.
For most product people and designers I know, the answer to that question is obvious. We are not the wait-for-the-polished-version type.
The tools exist. The protocol exists. Your WHOOP is already tracking 24/7. Your calendar is already there. The only thing missing is the interpreter — and you now have one, if you’re willing to set it up.
The open question I keep sitting with: as AI gets better at synthesizing our physical and cognitive context, what decisions should we let it influence — and where does the line between useful nudge and algorithmic override start to blur? I’d love to hear how you’re thinking about it.
References
WHOOP MCP Server (Open Source) — https://github.com/nissand/whoop-mcp-server-claude
Totem: Universal Wearables MCP Bridge — https://github.com/briangaoo/totem
WHOOP MCP Unofficial (Local-First) — https://whoopmcp.vercel.app/
How to connect a WHOOP MCP with Claude Code — https://www.merge.dev/blog/whoop-mcp-claude-code
WHOOP Expands Health Platform with On-Demand Clinician Access and New AI Features (May 2026) — https://finance.yahoo.com/sectors/healthcare/articles/whoop-expands-health-platform-demand-130000213.html
How WHOOP Coach uses AI to deliver personalized health guidance — https://www.whoop.com/us/en/thelocker/new-ai-guidance-from-whoop/
Fitness Wearables 2026: From Step Tracking to AI Coaching — https://thewellproven.com/fitness-wearables-2026/
Apple Health+ AI Coach Launches 2026 — https://apple.gadgethacks.com/news/apple-health-ai-coach-launches-2026-what-to-expect/
Unlocking Your Health Data: A Deep Dive into the Whoop MCP Server — https://skywork.ai/skypage/en/unlocking-health-data-whoop-mcp-server/1981559023663640576
MCP for WHOOP — https://mcpforwhoop.com/