How to Integrate Retool with Apple HealthKit

Before building anything in Retool, it is essential to understand why HealthKit cannot be queried directly and which bridge pattern fits your use case. HealthKit is an iOS framework that stores health data in a sandboxed on-device database. Apple restricts API access to native iOS apps with special entitlements — web services, internal tools platforms, and SaaS applications have no path to direct access. There are three practical bridge patterns to evaluate. The first is the Apple Health XML Export: iPhone users can go to the Health app → their profile icon → Export All Health Data to download a ZIP containing export.xml. This XML contains all stored health data and can be parsed programmatically into a database. This is best for one-time or periodic batch imports. The second pattern is iOS Shortcuts automation: using the iOS Shortcuts app, users can create personal automations that read HealthKit values (Health Records queries are not available, but personal metrics like steps and heart rate are) and use the 'Get Contents of URL' action to POST data to a server endpoint. This enables near-daily automated data delivery without native app development. The third pattern is using wearable APIs directly: if your health data actually originates from a Garmin, Fitbit, or Withings device, those manufacturers expose REST APIs that Retool can query directly — bypassing HealthKit entirely. For most enterprise scenarios, this third approach is both simpler and more scalable. Choose your bridge pattern before proceeding to the next steps.

If you are using the Apple Health XML export approach, this step covers importing the data into a queryable database. The Apple Health export produces a file called export.xml inside a ZIP archive. The XML structure uses an element called 'Record' with attributes including 'type' (e.g., HKQuantityTypeIdentifierStepCount), 'value', 'startDate', and 'endDate'. The file can be very large — years of health data from an Apple Watch can exceed 500 MB. To parse the XML efficiently, use a streaming parser rather than loading the entire file into memory. In Python, the lxml library with iterparse works well for this. Write a script that extracts records of each health type into separate database tables: steps_daily, heart_rate_readings, sleep_analysis, workouts. Create a PostgreSQL database (Supabase or a hosted PostgreSQL instance works well) with tables structured around the health metric types you need. A simple steps_daily table might include columns: record_date DATE, step_count INTEGER, source_name TEXT, user_id INTEGER. Run the import script locally or in a cloud function to load the XML data. Once the data is in PostgreSQL, configure a PostgreSQL Resource in Retool by clicking Resources tab → Add Resource → PostgreSQL, entering your database credentials, and saving. Test the connection to confirm Retool can reach the database.

1-- Example PostgreSQL table schema for HealthKit data
2CREATE TABLE health_steps_daily (
3  id SERIAL PRIMARY KEY,
4  user_id INTEGER NOT NULL,
5  record_date DATE NOT NULL,
6  step_count INTEGER NOT NULL,
7  source_name TEXT,
8  imported_at TIMESTAMP DEFAULT NOW()
9);
10
11CREATE TABLE health_heart_rate (
12  id SERIAL PRIMARY KEY,
13  user_id INTEGER NOT NULL,
14  recorded_at TIMESTAMP NOT NULL,
15  bpm DECIMAL(5,1) NOT NULL,
16  source_name TEXT
17);
18
19CREATE TABLE health_sleep (
20  id SERIAL PRIMARY KEY,
21  user_id INTEGER NOT NULL,
22  sleep_start TIMESTAMP NOT NULL,
23  sleep_end TIMESTAMP NOT NULL,
24  sleep_category TEXT, -- 'HKCategoryValueSleepAnalysisAsleep'
25  duration_minutes INTEGER
26);

For near-real-time health data delivery without native app development, iOS Shortcuts can read HealthKit data and POST it to a server endpoint. First, create a server endpoint that accepts JSON POST requests. A simple serverless function (Cloudflare Worker, Vercel Edge Function, or AWS Lambda) can receive the data and insert it into your database. The endpoint should accept a JSON body and store the records. In the iOS Shortcuts app on iPhone, create a new Shortcut. Add a 'Find Health Samples' action — choose the metric type (e.g., Steps), set the date range to 'Last Day', and set Sort by 'Start Date'. Add a 'Get Contents of URL' action configured as a POST request to your server endpoint URL. Set the Request Body to JSON, and construct the payload using the Shortcut variables from the previous step. Set this Shortcut to run automatically via a Personal Automation triggered each morning. This creates a daily pipeline from HealthKit to your database. In Retool, your dashboard queries the database the same way as with the XML import approach — through the PostgreSQL Resource you configured. The advantage of this approach over the XML import is freshness: data arrives automatically each day rather than requiring a manual export and import cycle.

1// Example server endpoint that receives iOS Shortcuts health data
2// Deploy this to Cloudflare Workers, Vercel, or AWS Lambda
3
4export async function handleHealthDataUpload(request) {
5  const body = await request.json();
6  const { user_id, date, metrics } = body;
7  
8  // metrics: { steps: 8432, resting_hr: 62, sleep_hours: 7.5 }
9  // Insert into your PostgreSQL database
10  
11  return new Response(JSON.stringify({ success: true }), {
12    headers: { 'Content-Type': 'application/json' }
13  });
14}

With health data accessible in a database, build the Retool dashboard. Open or create a Retool app and in the Code panel, create a query named 'getHealthMetrics'. Select your PostgreSQL Resource. Write a SQL query that retrieves the health data filtered by date range and user. Use Retool's date picker components to bind the date filters dynamically. A useful starting query retrieves daily step counts and calculates rolling averages. Add additional queries for heart rate trends and sleep analysis. From the component panel on the right side of the Retool editor, drag a Chart component onto the canvas. Set the Chart type to Line, set the Data property to {{ getStepsQuery.data }}, configure the x-axis to the record_date column and y-axis to step_count. Add a second Chart below it showing heart rate over time using similar configuration. Add a Table component for the raw daily metrics data. Add a Date Range Picker component at the top of the dashboard and bind both queries' date parameters to its value. Add Select components for filtering by user_id if you have multi-user data. For aggregate stats, add Statistic components showing 7-day average steps, average sleep hours, and average resting heart rate — calculate these values in JavaScript transformer functions attached to each query.

1-- Query: daily steps with 7-day rolling average
2SELECT
3  record_date,
4  step_count,
5  AVG(step_count) OVER (
6    ORDER BY record_date
7    ROWS BETWEEN 6 PRECEDING AND CURRENT ROW
8  ) AS rolling_7day_avg
9FROM health_steps_daily
10WHERE
11  user_id = {{ userSelect.value || 1 }}
12  AND record_date BETWEEN {{ dateRange.start }} AND {{ dateRange.end }}
13ORDER BY record_date ASC;

If your health data originates from a supported wearable device — Apple Watch, Fitbit, Garmin, or Withings — the most reliable long-term architecture is to connect Retool directly to those device manufacturers' REST APIs, bypassing HealthKit entirely. Garmin Health API offers OAuth 1.0a authentication and endpoints for activities, sleep, stress, and body composition. Fitbit Web API uses OAuth 2.0 with PKCE and exposes endpoints for steps, heart rate, sleep, and activity. Withings Health API uses OAuth 2.0 and covers weight, blood pressure, sleep, and activity data. These APIs are all queryable directly from Retool's REST API Resource — no bridge infrastructure required. To configure a direct wearable API connection, click Resources tab → Add Resource → REST API. Enter the base URL for the wearable API (e.g., https://apis.garmin.com for Garmin or https://api.fitbit.com for Fitbit). Set the Authentication type to OAuth 2.0 and configure the client credentials from the device manufacturer's developer portal. Retool's OAuth 2.0 support handles token refresh automatically. For complex integrations spanning multiple health data sources, custom data normalization transformers, and Retool Workflows for scheduled data synchronization, RapidDev's team can help architect and build your Retool health monitoring solution.

1// JavaScript transformer: normalize data from multiple wearable API formats
2const rawData = data;
3
4// Handle both Fitbit and Garmin response shapes
5const activities = rawData['activities-steps'] || rawData.dailies || [];
6
7return activities.map(day => ({
8  date: day.dateTime || day.calendarDate,
9  steps: parseInt(day.value || day.steps || 0),
10  source: rawData['activities-steps'] ? 'Fitbit' : 'Garmin'
11}));