Bartosz Michalak

Posted on Feb 2

Stop integrating wearables one by one - there's an open-source way

#api #iot #opensource #showdev

Hello all wearables enthusiasts!
(and everyone who just has to integrate with them! 😁)

If you're building a project with wearable data integrations, or just want to keep data from your personal wearables in one place - I believe you may find this article interesting. Here's a TL;DR so you can quickly assess if it's worth your time:

TL;DR:

Open Wearables = open-source alternative to expensive SaaS solutions that integrates data from hundreds of wearables
Single REST API for Garmin, Apple Health, Whoop, Polar, Suunto (and much more in the pipeline)
Self-hosted, no per-user pricing, you own the data
docker compose up and you're running

🚀 Wearables market is exploding

The popularity of wearables is growing year after year. The wearables market is worth over $200 billion in 2025 and is projected to grow to $500 billion by 2030. Over 86 million Americans (almost 1/4 of the US population) use health-related wearables. Smartwatches make up nearly half of this market.

CES 2026 was packed with health tech and wearables announcements - the industry is shifting from all-in-one devices toward specialization, with focus on battery life and AI as an active tool rather than passive tracking. Over half of the health-related exhibits were tied to the "longevity economy" (valued at $35 trillion, projected to reach $95 trillion by 2050).

If you're into Reddit, check out these subreddits to see how big the wearables communities are:

r/whoop - 132k members
r/ouraring - 297k members
r/garmin - 541k members
r/AppleWatch - 564k members

(if you're building something around wearables, I actually recommend browsing these subreddits - you'll find plenty of interesting problems that still remain unsolved)

Many people can't imagine working out without a watch on their wrist nowadays. If it's not tracked, it didn't happen!

💡 The untapped potential of wearables data

The devices collect massive amounts of data about us. For example, Apple Health has collected 5 million measurements from me over 7 years. Look at the ones that are the most numerous:

- HKQuantityTypeIdentifierActiveEnergyBurned: 1,934,715
- HKQuantityTypeIdentifierBasalEnergyBurned: 695,903
- HKQuantityTypeIdentifierHeartRate: 606,774
- HKQuantityTypeIdentifierDistanceWalkingRunning: 525,721
- HKQuantityTypeIdentifierStepCount: 339,895
- HKQuantityTypeIdentifierDistanceCycling: 156,524
- HKQuantityTypeIdentifierAppleStandTime: 117,785
- HKQuantityTypeIdentifierAppleExerciseTime: 84,134
- HKQuantityTypeIdentifierPhysicalEffort: 78,791
- HKQuantityTypeIdentifierWalkingStepLength: 50,668
- HKQuantityTypeIdentifierWalkingSpeed: 50,666
- HKQuantityTypeIdentifierRespiratoryRate: 45,750
- HKQuantityTypeIdentifierWalkingDoubleSupportPercentage: 42,814

There's a ton of raw data - and researchers are just scratching the surface of what's possible. Machine learning models are being used to predict health issues before they become critical. AI-powered wearable analysis can detect patterns in heart rate, sleep, and activity that humans would never spot. Studies show that continuous glucose monitors paired with AI are changing diabetes management. The challenge is getting all this data in one place and making sense of it.

If you want to build something meaningful with this data, you need to wrangle all these integrations yourself (or pay for an expensive SaaS). Unless you use something like...

🤔 What is Open Wearables and how can it help you?

Open Wearables is an open-source project that lets you pull data from hundreds of wearable devices through a single REST API. Instead of spending weeks wrestling with each provider's OAuth flows and data formats, you get one unified interface. It's self-hosted via Docker Compose, so you own your infrastructure and your data.

To give you a better understanding, we've prepared a diagram to show how wearables data typically flows:

As you can see, there are two ways to access wearables data:

Cloud-based (via REST API) - providers like Garmin, Whoop, or Polar expose their APIs, and Open Wearables connects to them directly
SDK-based (via Health SDK) - data lives only on the user's device (like Apple Health or Samsung Health), never hits the provider's cloud. You need a mobile app to access it and sync to your backend

Below is an example of how the Open Wearables Health SDK helps you sync user data with Open Wearables:

import 'package:health_bg_sync/health_bg_sync.dart';

class HealthService {
  Future<void> initialize() async {
    // 1. Configure the SDK
    await HealthBgSync.configure(
      environment: HealthBgSyncEnvironment.production,
    );

    // 2. Check if already signed in (session restored from Keychain)
    if (HealthBgSync.isSignedIn) {
      print('Session restored for ${HealthBgSync.currentUser?.userId}');
      return;
    }

    // 3. Get credentials from YOUR backend
    final credentials = await yourBackend.getHealthCredentials();

    // 4. Sign in with the SDK
    await HealthBgSync.signIn(
      userId: credentials.userId,
      accessToken: credentials.accessToken,
    );

    // 5. Request health permissions
    await HealthBgSync.requestAuthorization(
      types: [
        HealthDataType.steps,
        HealthDataType.heartRate,
        HealthDataType.sleep,
        HealthDataType.workout,
      ],
    );

    // 6. Start background sync
    await HealthBgSync.startBackgroundSync();
  }
}

That's it. The SDK handles background sync, retries, and data normalization. Open Wearables backend receives clean, unified data.

And when you need to fetch that data? Here's an example of getting daily activity summary:

import requests

response = requests.get(
    "http://localhost:8000/api/v1/users/{user_id}/summaries/activity",
    headers={"X-Open-Wearables-API-Key": api_key},
    params={"start_date": "2025-01-01", "end_date": "2025-01-31"}
)

# Returns daily aggregated metrics - same schema for all providers
# {
#   "date": "2025-01-15",
#   "steps": 8432,
#   "distance_meters": 6240.5,
#   "active_calories_kcal": 342.5,
#   "active_minutes": 60,
#   "heart_rate": {"avg_bpm": 72, "max_bpm": 145, "min_bpm": 52},
#   "source": {"provider": "apple_health", "device": "Apple Watch Series 9"}
# }

Simple as that! 🚀

🏗️ How is it built?

The entire project lives in a monorepo. Why? In the age of AI coding agents, monorepos make a lot of sense - LLMs work better when they can see the full picture of your codebase rather than jumping between scattered repositories. Plus, it keeps things simple: one repo to clone, one place to contribute, consistent tooling across all components.

*There's one exception to this rule - the Health SDK for Flutter lives in a separate repository.

Here's what's inside:

Backend – The heart of Open Wearables, powered by FastAPI. We use PostgreSQL for data storage and Redis for session management and caching. This is where the Provider Integration Layer lives, handling OAuth flows, data synchronization, and normalization into our unified schema.
Frontend – Our Developer Portal built with React + TypeScript. While developers use it to manage API keys, it's also useful for personal trainers monitoring their athletes or individual users who want to track health data for themselves and their families in one place.
Docs – Built with Mintlify. We focus on great developer experience, providing interactive guides and copy-paste code snippets to get you integrated quickly.
MCP – Model Context Protocol integration, so you can plug Open Wearables data directly into your AI workflows.

🚀 How to get started in minutes?

This project is built by devs, for devs. We, as core contributors, spent over 10 years building custom software for various clients - and used many different 3rd party services along the way. Some were great, but we also had plenty of frustrating experiences. That's why developer experience (DX) is our top priority here - we want Open Wearables to be the tool we wish we had.

We hate complex setups, so we made sure you can get up and running in minutes. You can start the entire stack with a single command:

docker compose up

Once you run this, you should see 7 up-and-running containers:

Then, you can run make init. This sets up your database and seeds it with real-world sample data so you can see the dashboard in action immediately. An admin account is created automatically during this process, so you can use the default credentials to log in:

admin@admin.com
secret123

Once you log in, you'll see the main dashboard:

You can see a quick summary of the system, like:

The number of users
Active connections
Total data points
A breakdown of different data types
And the latest users added to the system

The next tab you'll discover is Users.

And here’s the 'tricky' part which we're proud of: We built Open Wearables so that every action possible via API is also available in the UI. This means our platform isn't just for software developers - as mentioned at the beginning, it's powerful enough for personal trainers monitoring athletes or even families tracking their health data together.

So, if you're a software dev - you'll be using this panel mostly for monitoring purposes and managing API keys. But if you're a wearables enthusiast or personal trainer, this panel, after small adjustments, can be your operational center for wearables data! Just look at these charts you get out of the box:

If you're an Apple Watch user, the quickest way to test Open Wearables with your own data is through our demo app included in the Health SDK.

You can learn more about the SDK and how to use it in your Flutter app in the documentation.

💡 Why should you use Open Wearables as a developer?

Active community - We have a Discord server where the core team hangs out. Got stuck? Have an idea? Want to discuss a PR before submitting? We're there. There's also GitHub Discussions if that's more your style.
Full customization - It's open-source, so you can fork it, extend it, or rip out parts you don't need. Want to add a new niche wearable provider? We prepared a guide so you (or your favorite LLM) can do it without any hassle.
Skip the boring parts - I don't want to throw around lofty phrases like 'Save months by using X'. But just look at our git history, the number of commits and lines of code - building a stable solution that integrates wearables data is not a simple task. OAuth flows, token refresh logic, data normalization across different providers, rate limiting, webhook handling... we've already dealt with all of that (and still fighting).

👋 Who's behind this?

We're a small, but experienced team - we've been building health & fitness apps for clients for years and kept seeing the same integration problems pop up across different projects - so we decided to solve them once and for all. Oh, and most of us are wearables enthusiasts ourselves - we actually use this stuff daily.

Core contributors:

bartmichalak - Owns product vision and roadmap, but also actively contributes to the codebase.
KaliszS - Python, Rust and Go developer in one. Good luck getting your PR past his code review - he catches every LLM hallucination.
czajkub - Python dev, mainly responsible for Apple Health integrations.
farce1 - AI wizard, maxing out his capabilities with agentic AI workflows.
FBegiello - AI/ML specialist coordinating all AI implementations around wearables data.
Gasiek - Brought many beautiful colors to the developer dashboard.
Health Kowshik - Pushing forward MCP and WHOOP integrations.

👉 Next steps

If you made it this far - thank you for your attention! Holding someone's focus these days isn't easy, so I appreciate it. Drop a comment and let me know what you think about our platform. If you're wondering what to do next, here's what I'd suggest: