Webhooks
Real-time health data.
No polling required.
Webhooks push health events to your backend the moment they happen. A workout completes, sleep is recorded, a timeseries batch lands. Your endpoint fires immediately.
Register an endpoint in one request.
Polling health data doesn't work.
Open Wearables ingests provider webhooks so your application receives health data as it arrives rather than polling for it. Providers differ sharply here: Garmin delivers data exclusively through webhooks, which is why ingestion, backfill orchestration, and retry logic run on Celery workers with Redis-backed state, while others support a mix of push and scheduled sync. Open Wearables absorbs those differences and normalizes every payload into the same unified schema, so your code handles one event shape instead of one per provider. Raw incoming payloads can optionally be written to S3, which matters when reconstructing what a provider actually sent during an incident. Outbound webhooks, where Open Wearables pushes events onward to your systems, are still in development, so plan around reading from the API for now. Self-hosted and MIT licensed, so every payload stays on your own infrastructure.
Health events are unpredictable
You're always late
If you poll every few minutes, you're either wasting requests or missing the window entirely.
Polling overhead per 1,000 users
Wasted infrastructure
Polling at scale is expensive. Most requests return empty. Your backend processes load that produces no value.
Pull vs. push
GET /events every 5 min
// 99% empty responses
POST your-app.com/webhooks
// Fires exactly when data arrives
Push, not pull
Open Wearables sends an HTTP POST when the event occurs. Your system processes it once, immediately.
Every health event.
One delivery mechanism.
Open Wearables fires webhooks across the full data model. Timeseries payloads include
the complete samples array. No follow-up
API call needed.
Example payload
{
"type": "workout.created",
"data": {
"user_id": "u_123",
"provider": "garmin",
"duration_s": 3720,
"avg_hr": 142
}
}
- Workout created
- Sleep recorded
- Daily activity summary
- New provider connection
- Heart rate, HRV, steps, calories
- SpO2, respiratory rate, temperature
- Stress, glucose, blood pressure
- Body composition, fitness metrics, recovery scores
- Activity timeseries, workout metrics, environmental data
Delivery you can rely on.
Open Wearables handles the hard parts of webhook delivery for you.
If your endpoint is temporarily unavailable, data ingestion continues unaffected. Events queue and can be resent manually.
-
Automatic retries on failed deliveries
-
Cryptographic verification on every incoming request
-
Deduplication to prevent double-processing
-
Delivery logs with full attempt history
-
Test events to validate your integration before going live
Every payload is signed.
Verification is built in.
Each webhook delivery comes with a cryptographic signature. You can verify incoming requests with a single SDK call in Python or Node.js.
No forged requests get through. Stale deliveries older than 5 minutes are rejected automatically.
from svix import Webhook
wh = Webhook(secret)
payload = wh.verify(body, headers)
# Raises exception if invalid or expired
Only receive what you need.
Scope each endpoint to exactly the events and users that matter. Useful for multi-tenant architectures where different services handle different data streams.
Event filtering
Subscribe to specific event types only. Ignore what your service doesn't need.
filter_types: ["workout.created"] User scoping
Restrict an endpoint to a single user's events only.
user_id: "u_123" Combined routing
Combine both for granular, per-user, per-event routing.
filter_types + user_id Register an endpoint in one request.
POST your URL, retrieve your signing secret, send a test event. That's the full setup.
# 1. Register your endpoint
$ curl -X POST localhost:8000/api/v1/webhooks/endpoints \
-d '{"url": "https://your-app.com/webhooks"}'
# 2. Get your signing secret
$ curl localhost:8000/api/v1/webhooks/endpoints/{id}/secret
{"key": "whsec_..."}
# 3. Send a test event to verify delivery
$ curl -X POST localhost:8000/api/v1/webhooks/endpoints/{id}/test
Start receiving health events today.
Deploy Open Wearables, register your endpoint, and your backend starts receiving real-time data from every connected provider.
Self-hosted. Your data. MIT licensed.
Healthcare software & AI development agency specializing in turning health data into intelligent applications.
themomentum.aiCommon questions.
What is a webhook?
A webhook is an HTTP POST request sent by Open Wearables to your endpoint when a health event occurs. Instead of your backend polling for new data, Open Wearables pushes it to you the moment a workout is saved, sleep is recorded, or a timeseries batch is ingested.
What happens if my endpoint is down?
Data ingestion continues unaffected. Failed deliveries are retried with exponential backoff. Events queue and can be resent manually from the delivery logs once your endpoint is back online.
How do I verify webhook payloads?
Each delivery includes a cryptographic signature in the request headers. Retrieve
your signing secret from /api/v1/webhooks/endpoints/{id}/secret and verify incoming payloads using the Svix SDK for Python or Node.js, or implement
manual HMAC-SHA256 verification. Deliveries older than 5 minutes are automatically rejected.
Can I filter which events my endpoint receives?
Yes. Use filter_types to subscribe only
to specific event types, and user_id to
restrict an endpoint to a single user. Combine both for per-user, per-event routing.
Do timeseries webhooks include the full data?
Yes. Timeseries event payloads include the complete samples array. You do not need to make a follow-up API call to fetch the data after receiving
the webhook.
Is Open Wearables free to use?
Yes. Open Wearables is open source (MIT license). You pay for the infrastructure you deploy it on and nothing else.