Connecting Whoop to Claude

When where you work meets how you work out

How I really use it

The consumer age of health AI is unquestionably here.

I myself have converted to a wearable enthusiast as I jokingly noted in another article recently.

Most mornings, before I’ve had coffee, I ask my workspace a version of the same question: how did I recover, and what should I do about it today? Because my WHOOP data now lives inside Claude, the answer comes back grounded in my own numbers and earmarked to my calendar. I see my last night’s sleep against my 30-day baseline, where my heart-rate variability is trending, whether yesterday’s strain warrants backing off or ramping up. No app-hopping, no exporting, no remembering. It’s just there, in the place I already work.

I have a scheduled task in Claude that pulls my latest recovery, sleep, strain, and workouts and files them into a Longevity & Health folder on my desktop and a Notion page I use as a personal database. This becomes a clean, plain-text record of my physiology that compounds over time. And yes, this feels like a habit of the worried well, but it has contributed to me altering my habits to get my VO2 max up, improve my sleep and as many others cut back on late eating and drinking. And a living dashboard charts almost two years of trends the moment I open it, then tops itself off with last night’s data. The data I was already generating finally became useful to the person it’s about: me.

That shift from data I have to data I can think with has been a very pleasant and insightful experience. (And I haven’ve developed orthosomnia yet). It changed how I read my own training, my sleep debt, and the true cost of a bad week.

The build

Below, I walk through exactly how I set this up, every link you’ll copy, every moment you hand Claude the keyboard, plus a companion kickstart guide you can hand to your own Claude Cowork and follow along.

If you’ve ever wanted your wearable data to live where you actually think, this is the playbook. There’s also a no-developer-app shortcut near the end for the less technical route.

What you’ll need

Less than you’d think. The one thing people trip on is that connecting WHOOP to anything requires a WHOOP developer account — separate from the app on your wrist — and creating that app is a small project of its own (more on that in Step 1).

The short list. Most of the elapsed time is waiting, not working.

• A WHOOP membership and band. You’re already wearing the hard part.

• A WHOOP developer account. You sign in at developer.whoop.com with your WHOOP credentials, accept the developer terms, and create an “app.” It’s portal configuration, not coding — but it has a few steps to get through, and even my “one-click” plugin and MCP requires a developer app (for now).

• The Claude desktop app (Cowork). This runs the connection and hosts the dashboard.

• Node.js — which you probably already have. It’s a free runtime the connector needs. I had it and don’t remember ever installing it; it tends to ride along with other developer tools. Claude checks for you and, if it’s missing, points you to a one-click installer. Not something you wrangle by hand.

• About 15 minutes of active work (plus, optionally, a 24-hour wait if you take the export shortcut).

If a developer app intimidates you, there’s a simple export function you can use as well to get the insights in Claude. For the other wearable enthusiasts out there, Oura has a similar MCP (github repository still fiddly), and Strava has a Claude approved MCP as well.

The fastest way in — one click

When I first built this, I did it by hand: cloning a connector, editing config files, handing Claude my keyboard. You don’t have to. I’ve since packaged the whole thing into a Claude plugin plus a one-click WHOOP Connect extension:

→ github.com/DrMultivac/whoop-cowork

The plugin carries the skills and the dashboard. One click to add it.

The nicest part is the extension. Instead of editing any files, you paste your WHOOP developer keys right into the install dialog — and you’re connected.

No config files. You paste your keys here, and the connection is set up for you.

The whole flow:

1. Install the plugin and the WHOOP Connect extension from the repo. Fully quit and reopen Claude.

2. Paste your WHOOP Client ID and Secret into the extension’s install dialog (where to get them is the next section).

3. Say to Claude: Set up my WHOOP connection. Approve in your browser, paste the one-time code back (≈30 seconds, once). Then: Build my WHOOP dashboard.

That’s it. The connection refreshes itself from then on, and your dashboard lives in the Cowork sidebar.

The one prerequisite: even the one-click path needs a free WHOOP developer app to generate those keys — there’s no way around it; it’s how WHOOP gates API access for everyone. A few minutes of portal setup, covered next. Don’t want to bother? Skip to the export route — no developer app at all.

Getting your keys — the WHOOP developer app

This is the one real hurdle, so let’s be honest about it. At developer.whoop.com you sign in with your normal WHOOP login, accept the developer terms, and create an app. No code — but a few fields:

• App name + contact email.

• A Privacy Policy URL. WHOOP requires this field filled; a placeholder is accepted for personal use (a real one is only needed to publish the app for others).

• A Redirect URL (below).

• The six read scopes: recovery, cycles, sleep, workout, profile, body measurement.

Your app’s settings. The Redirect URI must match exactly; you’ll copy the Client ID + Secret from here.

📋 Copy-paste this. In Redirect URIs, paste exactly: http://localhost:3000/callback. Off by one character and login fails. Then copy your Client ID and Client Secret — those go in the extension’s install dialog.

⚠ The gotcha most people miss. A new app starts in development mode, which only works for WHOOP accounts you add as Test Users. Add your own WHOOP account first, or the login will bounce. Going fully public is a separate, weeks-long WHOOP review you do not need for personal use.

Authorize, once. After you ask Claude to “set up my WHOOP connection,” it gives you a link. Open it, approve, and WHOOP sends you to a page that looks broken — that’s expected. Your one-time code is in the address bar after code=; copy it (stop at the first &) and paste it back to Claude.

If at any point you’re having issues, take a screenshot of the step you’re stuck at and ask Claude “why am I stuck here?” and you will gradually get guided back to the final integration.

The page won’t load — that’s normal. The code is in the address bar.

No developer app? The export route

If the developer-portal dance isn’t for you — or you just want two years of history on day one — there’s a lower-tech route, and it’s actually how I started.

Profile → Settings → Data Export. The file arrives by email (up to ~24 hours).

• In the WHOOP app: Profile → Settings → Data Export → Export Data. WHOOP emails a ZIP of CSVs. It can take up to ~24 hours — see WHOOP’s export guide.

• Drop the CSVs into a folder and say: Import my WHOOP export and build my dashboard. No developer keys, no OAuth.

• The trade-off: a snapshot, not live — you re-export to refresh. But it’s the friendliest on-ramp, and a great way to seed your whole history at once.

The system that keeps it alive

A dashboard you rebuild by hand isn’t a habit — it’s a chore. The version I actually run refreshes itself, and you can copy the whole engine: a scheduled task writes a small feed file, a prompt bakes the visualization from it, and two more tasks re-bake it every morning and every Sunday.

The Longevity Command Center: a 3D “Helix of Time”, today’s vitals, and a Calendar × Recovery panel.

Build these with Claude Opus 4.8. The 3D work and the correlation reasoning are noticeably better than on smaller models — switch the model to Opus 4.8 before you paste a build prompt.

1) The feed

A daily task keeps a one-row-per-day JSON on disk, so the dashboard loads instantly and never hammers the API.

Create a scheduled task that runs daily at 7 AM and updates “Longevity & Health/WHOOP Data/whoop-history.json” with my latest WHOOP recovery, sleep, strain, and workouts — one row per day, labeled by wake time.

2) The visualization

One prompt builds an immersive Longevity Command Center — a 3D recovery helix, trend charts, a “what drives my recovery” correlation panel, and a Calendar × Recovery overlay that ties your physiology to your actual schedule (connect Google Calendar first). The short version:

Build a Longevity Command Center Cowork artifact from whoop-history.json: today’s vitals, a 3D three.js recovery orb, recovery/HRV/sleep trend charts, a Pearson-correlation “what drives my recovery” panel, and a Calendar × Recovery overlay using my Google Calendar. Bake the history in; refresh today live.

3) Keep it fresh

Two scheduled tasks re-bake it: one daily at dawn, one Sunday night that recomputes the calendar correlations and writes a “what moved this week” note. The full copy-paste recipe — every prompt, the cron times, the 3D and correlation logic — lives in the repo: https://github.com/DrMultivac/whoop-cowork

The real unlock — one workspace, every signal

Here’s the part I find most exciting, and it’s bigger than WHOOP. The reason this lives in Claude — and not in yet another app — is that everything else I track lives here too. My calendar, Granola meeting notes, and email map my professional life; my labs and a Lose It food export bring in bloodwork and nutrition; and the Consensus MCP grounds the coaching in actual research. When recovery, a brutal meeting week, a late dinner, and last quarter’s labs all sit in the same workspace, Claude can finally connect them — and plot my professional life against my physiology.

Calendar, Granola, labs, food, and research converge with WHOOP into one view.

Meet Dr. Atlas

Once the streams converge, I gave them a voice. A handful of prompts created Dr. Atlas — a performance-medicine coach persona who reads my morning recovery, today’s calendar, my latest notes and labs, and hands me one concrete lever for the day, sometimes with a cited insight from the literature.

A coach persona that ties the signals together — and knows its lane.

To be clear: Dr. Atlas augments my care team and does not replace my PCP. It’s a coach, not a clinician of record — and it always says so. The full recipe — the build prompt, the design system, the Dr. Atlas persona, and two alternate styles (a Metabolic Command Center and a calmer editorial “Quiet Signals” version) — is in the repo: github.com/DrMultivac/whoop-cowork/blob/main/docs/LONGEVITY-COMMAND-CENTER.md

Same pattern, different signal: a metabolic-health version built from a food-log export and labs.

Under the hood

You don’t need any of this to use it, but here’s what the plugin automates so it doesn’t feel like a black box.

WHOOP holds the data; a small local bridge fetches it; Claude turns it into the dashboard and a nightly archive.

The bridge is a local MCP server — a translator between WHOOP’s API and Claude, running on your own machine. Nothing leaves your computer except the request to WHOOP itself. I patched the off-the-shelf connector in two ways that turn it from a demo into something durable: it asks WHOOP for “offline” access (so the key renews instead of expiring hourly), and it saves and auto-refreshes that key in the background. You authorize once and never think about it again. A scheduled task then writes a daily snapshot + a one-row-per-day log into a folder you own — your physiology in plain files, forever.

When I built this by hand, the scariest moment was the “Allow Claude to control your computer?” dialog while it wired up the config. The packaged version skips that entirely — the extension handles its own setup — but it’s a good reminder that you stay in control the whole time.

Other wearables

WHOOP isn’t special here — the same pattern works for any wearable with an API. If you’re on an Oura Ring, a couple of well-documented community MCP servers will get you there:

• FelixWag/oura-ring-mcp — local SQLite mirror, 14 tools, OAuth2, ~5-minute setup.

• mitchhankins01/oura-ring-mcp — human-readable insights across sleep, readiness, and activity, with OAuth or a static token.

• A friendly walkthrough: Connect your Oura Ring to Claude Desktop.

Strava also has a Claude-ready connector if running and cycling are more your signal. The Oura repos are a touch more fiddly than what I’ve packaged here for WHOOP, but the idea is identical — and the same dashboard prompts work once the data is in.

Pick your style

Your dashboard doesn’t have to look like mine. Because Claude builds the artifact from your data, you can ask for almost any aesthetic — the same numbers can feel like a private bank statement, a video game, or a party. Four I prototyped (all in the repo, each with a copy-paste prompt):

Your Rhythm — warm, women’s-health-forward: a circular monthly rhythm, soft curves, dusty rose and sage.

Vitals Quest — an 8-bit game: recovery as an HP bar, a sleep meter, a gold streak, pixel hero and all.

The Morning Briefing — oak, brass, and leather: your vitals as an elegant private-bank dossier.

Tonight We Recover — neon, confetti, and a glowing vibe meter. Same data, maximum celebration.

Working prototypes and the prompts that generate each live in the repo: whoop-cowork/docs/prototypes. Pick one, or describe your own — “make my dashboard feel like a 1970s almanac” works just as well.

A closing thought

None of this is really about WHOOP. It’s about a pattern that’s newly within reach: take a stream of data you already generate, give an AI assistant a safe, read-only window into it, and let it do the boring, faithful work of collecting and visualizing , so the data finally becomes useful to the person it’s about. There are so many interesting things you can do with this data. You can interrogate it, build visualizations around your sleep, and finally see the long arc of your own health. The technology fades into the background. What’s left is a clearer view of you. How does this change the landscape of healthcare delivery? That’s a conversation for another day, but many would argue the commoditization of clinical intelligence is here, and the front door of healthcare is now in consumer’s hands. This is one small signal of the shifting sands underneath the feet of us all in healthcare.

The best part of this newsletter isn’t the tips. It’s the people reading them. Subscribers here have teamed up on projects, swapped workflows, and pushed each other’s work forward. I’ve collaborated with several of you myself.

If something here has saved you time or sparked an idea, share it with one person who’d benefit. That’s it! One person. Group subscriptions get a discount, and the button below does the rest.