How to Integrate Multiple Wearable APIs: A Complete Developer’s Guide
- Written by: Thryve
- 10 minutes
As health and wellness apps scale, developers are increasingly facing the complex reality of integrating multiple wearable APIs—each with its own unique process, technical documentation, rate limits, and approval requirements. What appears straightforward on the surface often leads to weeks of developer time spent interpreting how Fitbit differs from Garmin, or how Suunto’s data policies differ from those of Withings or Oura.
Some platforms, like Fitbit and Withings, allow for relatively quick onboarding through public developer portals, enabling sandbox access with minimal friction. Others, including Garmin and Suunto, involve longer application processes that may include manual reviews, approval criteria, and sometimes partnership-level engagement. These differences create a fragmented development experience that can delay product launches and burden already burdened engineering teams.
This guide aims to help developers and digital health product teams understand and navigate these distinctions step-by-step. Whether you’re integrating your first device or scaling to a fully interoperable platform, you’ll find clarity on each API’s nuances—and discover how Thryve simplifies the journey by offering a single, unified, and developer-friendly integration layer across all major wearable ecosystems.
Why a Unified API Approach Matters
While wearable APIs provide access to rich streams of user health data, such as steps, heart rate, sleep cycles, and HRV, the path to integration is rarely uniform. Each provider operates with its own technical aspects, authentication schemes, developer permissions, and access models. For instance, Fitbit and Withings offer relatively open access through public developer portals, allowing developers to register and start building quickly. In contrast, Garmin and Suunto require a more formal process, including application reviews and approval based on business use cases.
These differences make multi-device integration a time-consuming and often frustrating process. The learning curve can be steep, especially when juggling API limits, token refresh logic, or data normalization across platforms.
We have already covered the advantages of the unified health Data API. Nevertheless, it is worth mentioning that Thryve eliminates the mentioned challenges by serving as a unified, developer-friendly layer that abstracts away the complexity of multiple wearable APIs. Product teams benefit from:
- Unified authentication and token handling across all major device ecosystems
- A standardized data model that harmonizes metrics from different platforms
- Built-in support for GDPR compliance and data privacy standards
- Tools for streamlined error tracking and integration monitoring
By centralizing access and reducing the friction of wearable data integration, Thryve helps teams speed up development and spend more time delivering meaningful health experiences to their users.
Creating Your Garmin App
Overview:
Garmin’s Health API provides access to high-quality physiological metrics, including activity, heart rate, sleep, and stress. It is a powerful tool, but it requires a formal application and approval through Garmin’s partner program.
Prerequisites:
- Garmin Developer Account
- Completion of the Garmin Connect Program application
- A defined use case and company information to support your request
- Thryve tenant fully set up before app configuration
Steps:
- Start by submitting a request to join the Garmin Connect Developer Program at developer.garmin.com. You’ll need to describe your app, its purpose, and your company background. Review typically takes up to 2 business days.
- Once accepted, Garmin will issue a consumer key and secret that you’ll use for API authentication.
- Share these credentials securely with Thryve via our encrypted secret sharing system.
- Identify which scopes or data types you plan to access (e.g., heart rate, activity, stress). This doesn’t need to be final—we can update it later upon request.
- Thryve will set up your environment and confirm integration is complete.
Tips:
- Garmin’s model relies on push-based data delivery through webhooks. While on-demand fetching is not supported, data is typically pushed within a few minutes of capture—though slight latency can occur.
- Once active, Garmin requires regular data usage reporting and consistent data management practices.
If needed, you can visit the Help Center: Garmin Setup to gain a complete understanding.
Creating Your Fitbit App
Overview:
Fitbit’s Web API allows access to rich user data, including heart rate, activity, and sleep. The platform supports OAuth 2.0 for authentication and offers both personal and production-ready applications.
Prerequisites:
- A Fitbit account (used for both the developer portal and API access)
- Website link, privacy policy, and terms of service for your app
- Thryve tenant fully set up before proceeding
Steps:
- Create a Fitbit account and sign in at dev.fitbit.com
- Register your application under “Register an app”
- Application type: Server
- Default access type: Read only
- Add app name, description, and links to your privacy policy and terms
- Set up your redirect URI:
- Use: https://${partnerName}.und-gesund.de/dataSourcesSwitch.html
- Add a subscriber for webhook functionality:
- Subscriber type: JSON body
- Endpoint URL: https://${partnerName}.und-gesund.de/dynDataSourcePing/Fitbit
- Share credentials with Thryve:
- After app creation, you’ll receive a Client ID, Client Secret, and Subscriber Verification Code
- Encrypt and share them using Thryve’s secure secret sharing process
- After Thryve confirms setup, verify your subscriber in the Fitbit portal to enable ping messages
Tips:
- Ensure your Thryve environment is active before proceeding
- Your app must be verified to access production data
- Thryve handles OAuth management, reducing implementation complexity
Creating Your Oura App
Overview:
The Oura Cloud API offers access to scientifically validated insights into sleep, readiness, and activity. It supports secure OAuth 2.0 flows and is a valuable source of daily summary data.
Prerequisites:
- An Oura account created via the Oura mobile app
- Access to the Oura developer portal
- Thryve tenant fully set up before app configuration
Steps:
- Sign in to the Oura Cloud developer portal using your Oura account
- Under “API Applications,” register a new application:
- Add app name, contact email, website, privacy policy, and terms of service
- Configure the redirect URI:
- Use: https://${partnerName}.und-gesund.de/dataSourcesSwitch.html
- Under Authentication, check both:
- “Allow server-side authentication (grant-type code)”
- “Allow server-side authentication (grant-type token)”
- Once the app is created, you’ll receive a Client ID and Client Secret
- Share credentials with Thryve using our secure secret sharing tool
- When Thryve confirms the integration is live, you may begin production setup
Tips:
- Oura allows up to 10 users in development mode
- To request access for all users, you must submit the app for review via the portal
- At least one user must be connected before submission
- Thryve handles connection logic, but you must initiate approval once integration is confirmed
Creating Your Withings App
Overview:
The Withings Public API allows individuals and organizations to securely access a wide range of health metrics, including activity, sleep, and heart rate data—provided that users grant permission. No enterprise contract is required to begin integration.
Prerequisites:
- A Withings account (we recommend creating one specific to your organization using a shared, professional email)
- Access to the Withings developer portal
- Thryve tenant must be fully set up before app registration
Steps:
- Log in to the Withings developer portal with your organization’s account
- Register a new application under “Application Creation”:
- Choose “Public API integration” as your integration type
- Add your app name, organization email, website, privacy policy, and terms
- Register your redirect URI:
- Use: https://${partnerName}.und-gesund.de/dataSourcesSwitch.html
- After your app is created, you’ll receive a Client ID and Client Secret
- Share these credentials securely with Thryve using our encrypted secret sharing system
- If needed, apply for the Withings Enterprise Plan to exceed default rate limits (5,000 users and 120 requests per minute)
Tips:
- Default API limits may suffice for early use but are extendable via direct request to Withings
- Ensure all variables using ${partnerName} are filled in according to your Thryve registration
- Thryve will handle the technical implementation and notify you once the credentials are successfully integrated
Creating Your Suunto App
Overview:
The Suunto Cloud API provides access to user workout data, including tracked activities (e.g., running, cycling), daily step counts, and sleep metrics. Access requires a formal API request and developer onboarding.
Steps:
- Complete the Suunto API application form via their partner portal.
- Sign the contract with Suunto to activate production-level access.
- Add Thryve as a developer in your Suunto API zone using the following:
- Name: Thryve Developer
- Email: developer@thryve.de
- Apply for access to the Suunto Cloud API by completing their online request form. Be prepared to provide details about your company and application. Suunto typically responds within two weeks.
- In the application form, under the “co-operations” section, select: “I want to have access to Suunto Cloud API”
- Once your request is approved and the contract is signed, select at least the following features:
- Workout data (e.g., running, swimming, cycling)
- Daily measurements (e.g., steps)
- Nightly sleep measurements
- List Thryve as a developer on your account with the email developer@thryve.de. This grants us direct access to your Suunto API zone to facilitate setup.
- Thryve will handle environment setup based on your API access. Please share the list of data types you plan to use (these can be adjusted later).
Tips:
- There is no sandbox mode; testing is done using live accounts
- Suunto uses a batch data model; updates are not available in real-time
- Suunto’s approval process may take up to two weeks, so plan integration timelines accordingly
Creating Your Polar App
Overview:
Polar’s AccessLink API provides detailed data on daily activity, heart rate, sleep, and training sessions—ideal for wellness applications and athletic performance tracking.
Prerequisites:
- Apply for a Polar developer account
- Production access requires application review
Steps:
- Register your app via Polar Flow for Developers
- Generate client credentials and define the callback URL
- Authenticate users via OAuth 2.0
- Set up webhook endpoints to receive updates on user training and metrics
Tips:
- Webhook delivery is event-based; polling is not supported
- Sandbox environment has limited data simulation capabilities
- Data is structured around training sessions, not just daily summaries
The Complexity of Integrating Multiple APIs Manually
While wearable APIs open the door to a plethora of health data, managing multiple integrations across providers quickly becomes a complex and time-consuming task. Each platform has its own unique authentication system, data format, rate limits, webhook structure, and documentation quirks. Fitbit uses one OAuth flow, Garmin another. Oura prioritizes daily summaries, while Polar favors session-level detail. These differences create technical debt, increase the risk of errors, and stretch already-limited development resources. Scaling across devices often means multiplying engineering effort—and slowing down product timelines.
The Solution: Thryve as a Unified Connectivity Layer
Thryve simplifies this process by offering a single, developer-friendly connectivity layer across all major wearable APIs. With one integration, platforms can:
- Authenticate users across devices using a unified OAuth framework
- Harmonize and normalize health data into a consistent, structured model
- Ensure GDPR and HIPAA compliance with built-in data governance tools
- Monitor integrations in real time and streamline error tracking
Instead of maintaining multiple, evolving connections, Thryve helps development teams reduce overhead, move faster, and focus on building great user-facing health experiences—not managing back-end infrastructure.
Ready to simplify your wearable integrations?
Book a demo to see how Thryve can accelerate your health data strategy.
