LifeCare.ID® developer documentation
Build on a patient-controlled identity, consent, and authorization layer for health data that stores no health data, ever.
LifeCare.ID® lets your application authenticate users with a self-sovereign identity and request machine-readable, cryptographically signed, revocable consent over a person's health data, wherever that data actually lives. A full compromise of LifeCare.ID® yields tokens, public keys, and consent metadata, never a single health value.
This documentation is for two kinds of developer:
| You are building… | Start here |
|---|---|
| An application that signs users in and reads consented health data (a coach, a clinic portal, a research tool) | Getting started → Authentication (developer access) |
| A data source / connector that holds data and serves it to authorized requesters (a device bridge, a lab feed, a home node) | Data sources & connectors (developer access) |
The status legend (read this first)
LifeCare.ID® is shipping incrementally. To keep this documentation honest, every capability is tagged:
- ✅ Live, implemented today in the service API. You can build against it now.
Backed by the published contract in
docs/contracts/openapi.json. - 🛣️ Roadmap, a planned capability of the future developer portal and network. Documented here so you can design toward it, but not yet available. Don't build against a roadmap feature expecting it to exist.
Where a page mixes both, each section carries its own tag. When in doubt, the contract file is the source of truth for what exists.
Pages marked (developer access) open after the email sign-in at app.lifecare.id/devaccess, the same one the hosted sandbox needs. The others are public.
The two-sided network
LifeCare.ID® is the trust fabric between people, the apps they use, and the places their data lives. It is not a data store, an aggregator, or a proxy.
┌─────────────────────────────────────────────────────────┐
│ LifeCare.ID® │
│ identity (DIDs) · consent (receipts + ledger) · │
│ authorization (UMA-style tokens + revocation) │
└───────▲───────────────────▲───────────────────▲─────────┘
│ sign-in / │ grant / revoke │ token
│ token │ consent │ validation
┌────────────┴──────┐ ┌─────────┴────────┐ ┌──────┴───────────┐
│ Relying-party │ │ The person │ │ Data source / │
│ APP (requester) │ │ (DID holder) │ │ connector │
│ e.g. ProForta │ │ device-held key │ │ (resource host) │
└─────────┬─────────┘ └──────────────────┘ └──────┬───────────┘
│ │
│ raw data flows DIRECTLY, app ↔ source │
└────────────────────────────────────────────┘
(LifeCare.ID® is never in this path)
The invariant. For any data value d held by a resource holder R and
delivered to a requester Q, the transfer R → Q is direct. No LifeCare.ID®
component is an intermediary, cache, proxy, or co-processor of d. LifeCare.ID®
participates only in {DID, public key, token, scope, consent receipt,
revocation status}. This is an architectural guarantee you can rely on, and a
rule your integration must respect (see Security & compliance).
Core roles
| Role | Who | What they hold |
|---|---|---|
| DID holder (the person) | end user | the private signing key, on their device (never leaves it) |
| Relying-party app | your app | a client_id/client_secret, user sessions, access tokens |
| Data source / connector | a resource host | the actual data + the obligation to honor tokens |
| Authorization server (AS) | LifeCare.ID® | DID authority, consent registry, token issuer, revocation registry |
| Trust partner | a medical practice (prod) / node operator (MVP) | approves identity recovery / key rotation |
See Concepts for the full model.
Documentation map
Foundations - Trust model, the four mechanisms behind every trust claim (consent receipt, patient-held authorization server, zero egress, node attestation), what each means for your integration, and the honest ceiling on attestation ✅ - Concepts, DIDs, identity custody, the AS, scopes, consent, the invariant - Bill of rights, why you can't be deplatformed: the structural guarantees (and the honest levers) ✅ - Getting started, a relying-party app, end to end, in minutes (with cURL / JS / Python) - Read a person's health context, end to end (developer access), the sequel: the two-system model, who the node's member routes serve, where a third-party app reads under a grant, and the Sense/Watch/Reason/Learn/Guard capability map ✅ / 🛣️ - Sandbox, self-serve a client + a passkey-free test identity; engage with no access request ✅ - From sandbox to production, every difference between the two and the steps to promote an app ✅ - Sandbox data source: synthetic health data to read under sandbox consent, over REST and MCP, and the authorization code flow a stock MCP client follows; a test fixture that behaves as a conforming data source ✅ - Sandbox kit ↗: the Apache-2.0 kit for building against the sandbox: the synthetic source and its tests, the public contract and an MCP Registry entry, the Pages reference deployment, a Compose file that runs the source on your machine against the hosted sandbox, one example client for the whole loop - Quickstart repos ↗, clone-and-run reference apps (an app + a data source), zero dependencies
Building an app - Authentication (developer access), sign a person in through LifeCare.ID® with OAuth 2.0 + PKCE ✅ - Onboarding & accounts (developer access), design patterns for account creation + onboarding, and the pitfalls ✅ - Your data & the DID (developer access), keying your CRM on the DID: the data boundary, durability, revocation/retention, and your responsibilities ✅ - Scopes & consent (developer access), the scope vocabulary, purpose binding, receipts, the ledger ✅ - Authorization & tokens (developer access), UMA-pattern data-access tokens, introspection, revocation, and the OAuth data-scope flow ✅ - Embedding the consent panel (developer access), the "Powered by LifeCare.ID®" data-rights panel ✅
Agents
- Connect an MCP agent: discovery, the person's yes on the LifeCare.ID® origin, a single-scope token, step-up, revoke ✅
- Client-ID metadata documents: how the issuer will admit an agent that identifies itself by a metadata document, at the lowest tier and on the person-managed terms. Policy ruled; live on the sandbox, production gated
- The device grant: how an agent with no browser asks, the flow in plain terms and the phishing mitigations the issuer will apply. Ruled; the sandbox implementation follows the note
- Person-managed authorization: the library for an agent that asks the person once and for a server that checks the grant at every request. Draft 1 ✅
- Agent trust (developer access), the manifest and vouching-status schemas, and the resolvable / vouched / attested ladder a delegated token's trust field names 🛣️ (defined, not yet operative)
Building a data source - Data sources & connectors (developer access), joining the network as a resource host ✅ / 🛣️
Guides - Build a care service on the network: the reference design for a care service, an app or an agent, on the network: what you build and what the network carries, three shapes of service, and where each piece stands - Recipes, task-oriented how-tos: verify-node badge, embed the panel, become a CGM source, handle revocation ✅ - Building with a coding agent: one paste-ready file of rules, the map and a runnable sandbox flow for the coding agent that builds on LifeCare.ID®, also served as agents.md - Person-managed authorization: the library for an agent that asks the person once, keeps the receipt and stops at the stop, and for a server that checks the grant at every request. Draft 1; built in the sandbox kit, not yet published
Reference - API reference, the full endpoint catalogue (today's contract) ✅ - Security & compliance, the zero-PHI invariant, your obligations, and verifying a node you integrate with ✅ - Procurement & compliance, a self-serve pack for security reviewers (zero-PHI, BAA, GDPR, audit trail) ✅ - Roadmap, what's live, next, and trigger-gated ✅ · changelog ↗ - Developer terms, the terms you accept to get access ✅ - The developer portal (developer access), self-service: sandbox client registration + access gate live ✅; full portal (production registration, keys, governance) 🛣️
Status today
LifeCare.ID®'s L1 to L3 layers (identity, consent, authorization) and the federation handshake (OAuth 2.0 + PKCE) are live. App and data-source onboarding is operator-mediated today (your client is provisioned by the network operator) and self-service via the developer portal is on the roadmap, that gap is exactly what the portal page describes. On the hosted sandbox, client registration, resources and the OAuth data-scope flow are self-service and live. Everything you need to integrate functionally exists now.
The health capabilities, interpreted context and (on the roadmap) events, intelligence and safety, are served by the node, not by LifeCare.ID® (which by invariant holds no health data); a third-party app reads them under a grant, on the sandbox data source today. Read a person's health context, end to end is the map of that surface and what's live vs roadmap.