LifeCare.ID® Developer Docs Public

From sandbox to production

The sandbox matches production except where it must: the same handlers, the same tokens, the same receipt, with synthetic people and self-service in place of real members and an operator. This page is the complete list of the differences, so moving an app from one to the other is a known set of changes and not a discovery. A test in the repository keeps it complete: it fails when a sandbox route, a deployment setting or a profile key exists that this page does not account for. The rule that the sandbox matches production except where it must is a program ruling, D-PL4.

Every row of the table carries one status word. same is by design and is listed so you stop wondering. sandbox-only exists in the sandbox and not in production. production-only exists in production and not in the sandbox. planned is a production mechanism that does not exist yet, named honestly, with no date. operator is a value the operator sets for each deployment, or a step the operator does for you.

The differences

Area What the sandbox does What production does What you change when you promote Status
Identities and sessions POST /v1/sandbox/test-identity mints a synthetic person and a session. No passkey, no terms, no age. The body is an empty object. It is how an agent or a CI job with no browser gets a session. No such route. A member always registers and signs in with a passkey (the next row). Drive the real passkey ceremony in place of the synthetic session. The data token still comes from the authorization code flow. sandbox-only
Identities and sessions A person registers a passkey at https://sandbox.lifecare.id with user verification required (LIFECAREID_REQUIRE_UV), accepts the current terms version, confirms they are 18 or older, and signs in with the passkey: the same routes, pages and checks as production. The create and sign-in pages add one sentence saying this is the sandbox and the identity holds synthetic data. The relying-party ID is sandbox.lifecare.id (LIFECAREID_RP_ID), so a sandbox passkey is offered and accepted only on the sandbox, and a production passkey is never offered there. The same ceremony at https://app.lifecare.id, user verification required, with the relying-party ID lifecare.id. Nothing in your app: the ceremony runs on the issuer's pages. A sandbox passkey does not carry over; the person signs in with their production passkey. operator
Identities and sessions On the sandbox a person creates an identity with the passkey alone: the create page has no recovery field, the sign-in page has no recovery link, a recovery_email sent to POST /v1/identity/register/begin or /finish is set aside, and /recover, POST /v1/recovery/email/begin, POST /v1/recovery/email and POST /v1/recovery/begin answer 404. The sandbox sends no mail and holds synthetic data only; on the sandbox a lost passkey means making a new identity. The create page requires a recovery email. It travels inside the one passkey ceremony that creates the identity (sent to register/begin, bound to its challenge, stored unconfirmed at register/finish) and is confirmed by a one-tap link, and a lost passkey is recovered with a magic link to that address. With LIFECAREID_REQUIRE_RECOVERY_EMAIL on, the issuer refuses a new identity that arrives without one. Changing the address later takes the person's passkey. A replacement address waits seven days by default (LIFECAREID_RECOVERY_EMAIL_CHANGE_WAIT_SECONDS) before it recovers the account, while the address it replaces is told and keeps working. Nothing: the person's recovery is production's own flow, on the issuer's pages. production-only
Identities and sessions POST /v1/identity/register exists, in the published contract: a public key plus terms and age, no passkey ceremony. The same route, the same behaviour. Production sign-in is still always a real passkey ceremony; this route creates an identity, it does not sign anyone in. Nothing. same
Identities and sessions Session lifetime is the default 86400 seconds. Cookies are __Host-lc_id_session over https; the old name is read for one release. The same lifetime and the same cookie names. Nothing. same
Identities and sessions The DID host is sandbox.lifecare.id (LIFECAREID_DOMAIN, with LIFECAREID_BASE_URL for the service's own address). A synthetic person has no recovery. Production DIDs carry the node's own host today, which does not resolve from the internet; it is replaced by a public host when the node goes public. A DID minted in the sandbox means nothing in production. Recovery is a magic link sent through the email relay. Store no sandbox DID; a production person brings their own. Do not resolve a production DID over did:web yet; read it with GET /v1/identity/resolve/{did} on the issuer. planned
Identities and sessions The email sender is the console (LIFECAREID_EMAIL_SENDER): the mail is logged, not delivered. The sandbox sets no webhook. The sender is a webhook to an email relay (LIFECAREID_EMAIL_WEBHOOK_URL, with LIFECAREID_EMAIL_WEBHOOK_SECRET in the service's env file) and an alert address (OPERATOR_ALERT_EMAIL) is set. Nothing; mail is delivered only in production. production-only
Client registration Self-service: POST /v1/sandbox/clients takes name, redirect_uris and optional resources, and returns client_id (prefix sbx_) and a secret. The owner is the developer's email, stored as a hash and never returned. Operator-provisioned. You ask the operator for a client. Ask the operator for a production client with the same redirect_uris. operator
Client registration No public clients (LIFECAREID_OAUTH_PUBLIC_CLIENTS is unset). A self-registered client is always confidential, with a secret. Two native app clients are public (PKCE, no secret), listed by the operator in LIFECAREID_OAUTH_PUBLIC_CLIENTS. A new public client is an operator addition. If your app is native and cannot keep a secret, say so in the request to the operator. production-only
Client registration Public clients identified by a client-ID metadata document (CIMD) are live on the sandbox, switched on by LIFECAREID_CIMD_PUBLIC_CLIENTS (the sandbox value is on). A client uses an HTTPS URL as its client_id, with no registration call, and gets PKCE S256, no shared secret, no refresh token, one data scope and one resource per token. The document may allow none, private_key_jwt (the client signs an assertion with a key set its document carries, jwks or jwks_uri) or both; the contract is 0.30.0 on the sandbox. The consent page shows the client's hostname and "not reviewed", unless the operator named the hostname in LIFECAREID_CIMD_NAMED_PLATFORMS (empty on the sandbox). The policy and the refusals are at client-id-metadata.md. LIFECAREID_CIMD_PUBLIC_CLIENTS is off until AI-PROD-CIMD (gated), so a URL client_id is refused as an unknown client, and the discovery documents do not carry client_id_metadata_document_supported. The same code runs on both. Until production switches it on, ask the operator for a production client. Do not build a flow that depends on a metadata document there. sandbox-only
Client registration The sandbox accepts an http loopback redirect URI (localhost, 127.0.0.1 or [::1]) in a client-ID metadata document and ignore the port when it matches, so a local coding agent can walk it. Production refuses a document with a loopback or localhost redirect: every redirect must be HTTPS. Register an HTTPS callback for production. sandbox-only
Client registration The operator's own web client is not configured: no LIFECAREID_OAUTH_REDIRECT_URIS, and the sandbox profile sets no LIFECAREID_OAUTH_CLIENT_ID or LIFECAREID_OAUTH_CLIENT_SECRET. Clients come from the registry. The operator's own web client has its redirect URIs in LIFECAREID_OAUTH_REDIRECT_URIS and its secret in the service's env file. Nothing; this is the operator's client, not yours. production-only
Client registration No first-party clients or grantees: LIFECAREID_FIRST_PARTY_CLIENTS, LIFECAREID_FIRST_PARTY_GRANTEES and LIFECAREID_MEMBER_ONLY_GRANTEES are unset. The operator's own node and app are first party, so a token can be issued over a grant that names the operator's own app. A third party is never first party. Nothing. A third-party app obtains a token only over a grant that names it. production-only
Client registration No first-party resource: LIFECAREID_FIRST_PARTY_AUDIENCE is unset, so no token from POST /v1/token carries an aud. The operator may name the first party's own node there. POST /v1/token then stamps that resource as aud when the caller is the person, by their own live session or a signature by their own DID, or a first-party client, and the grant runs to the person's own DID or to a first-party grantee. A client that is neither obtains a token without it. The authorization code flow refuses that resource, or a variant of it, as a resource (invalid_target). Nothing. Take your data token from the authorization code flow, whose aud is your own resource; a server of yours refuses a token whose aud is not its own, on both deployments. production-only
Client registration Service clients (LIFECAREID_SERVICE_CLIENTS) are held by the deployment. The secret lives in the env file, never in a profile. The same arrangement, with the operator's own service clients. Nothing; the operator issues server-to-server credentials. operator
Client registration A pending sign-in request expires after 1800 seconds for the operator's web client only (LIFECAREID_AUTHORIZE_PENDING_TTL_SECONDS, LIFECAREID_AUTHORIZE_PENDING_EXPIRY_CLIENTS: the sandbox runs the defaults). The same, set explicitly. No other client is affected on either deployment. Nothing. same
Resources Your own server can be registered as a resource on your clients (resources, one to five absolute URLs). A resource you registered is accepted as the resource of an /authorize request from any of your own clients. A few addresses are reserved for another developer (LIFECAREID_SANDBOX_RESERVED_RESOURCES): registering one answers 403. There is no registry. Once data scopes are on, /authorize accepts only the resources on the operator's allow-list (LIFECAREID_OAUTH_DATA_RESOURCES). Ask the operator to put your server's resource on the allow-list, instead of registering it on a client. sandbox-only
Resources Registration trusts the developer's email as the owner of the URL. That is not proof of control of the URL. The allow-list is decided by the operator. Production has no way yet to prove that you control a resource URL, and registration by email does not prove it; a proof of control is needed before production can accept a resource the way the sandbox does. Expect the operator to ask how you control the URL until a mechanism exists. planned
Resources The sandbox source's own address is on the allow-list by default, so everyone can ask for a token for it. The same default entry, once production runs a release with data scopes. Nothing. same
Data Synthetic, zero-PHI data only: five personas behind the hosted sandbox source. Real members' data, under the member's consent, at the sources the member connects. Point your app at the real sources the member has granted. sandbox-only
Flags Data scopes are on (LIFECAREID_OAUTH_DATA_SCOPES): /authorize accepts one data scope with an RFC 8707 resource, and POST /data-consent/decide answers. Off. Production treats such a request as a plain sign-in: it ignores the data scope and the resource, raises no error, and the code does not exchange for a data-access token. Data scopes are not yet switched on in production; switching them on is planned, with no date. Nothing yet; production cannot issue the token you obtain in the sandbox until the flag is on. planned
Flags Consent narrowing (LIFECAREID_OAUTH_CONSENT_NARROWING) is off by default and arrives on the sandbox when its deployment sets it: the grant question lets the person choose 30 days (as asked), 7 days or 1 day (or, when an identical grant stands, keep it or end it sooner), never longer, and the grant, the receipt, the panel and the ledger carry the chosen end. Off, and not yet switched on; it follows data scopes, planned with no date. Never assume 30 days: the grant's end is not returned to the client today (expires_in and expires_at are the token's own end, at most 1200 seconds); a token never outlives its grant. When a token reaches its own end or a code is refused with invalid_grant, ask the person again; a 401 invalid_token inside a token's life remains the person's stop. planned
Flags Discovery lists the data scopes and the RFC 8414 alias, and authorization redirects carry iss (RFC 9207), when data scopes are on. Production's discovery documents follow the same flag, so they do not list them while it is off. Its redirects carry no iss while the flag is off. Read the issuer's discovery document for the deployment you call; do not copy one. planned
Flags Caller authentication is on (LIFECAREID_REQUIRE_CALLER_AUTH, since 2026-11-05): grant, token, ledger, grants and revoke take a credential. On, with the same effect; production's 401 detail is worded differently until its next release. Nothing. same
Flags The access-record rule: a source that is not first party records an access only under an active grant it served for that person. Not yet: production receives the rule with its next release. Nothing; build to the sandbox's rule. planned
Flags Grant proof (LIFECAREID_REQUIRE_GRANT_PROOF) and holder signature (LIFECAREID_REQUIRE_HOLDER_SIGNATURE) are off. Off. Nothing. same
Flags The person's passkey on the grant question arrives with LIFECAREID_REQUIRE_GRANT_PROOF, off on the sandbox until its deployment sets it: a yes to a client outside the first party counts only after the person confirms it with their passkey on the LifeCare.ID® page, and the receipt carries the proof over the exact terms. With it on, the headless yes with a synthetic test identity is refused (that identity has no passkey); a yes needs a person created on the sandbox's create page. Off today. Production opens data scopes with it on. Nothing in your client: the flow and the code exchange are unchanged, and a refused yes is access_denied. Plan your sandbox tests for a person who confirms with a passkey. planned
Flags Identity creation on the authorization page (LIFECAREID_AUTHORIZE_OFFERS_CREATE) arrives on the sandbox first, when its deployment sets it. A person with no session who reaches /authorize with a valid request for a data scope then sees, on the LifeCare.ID® origin, who is asking and what, and chooses between creating a LifeCare.ID® there and signing in. Creating runs the same passkey ceremony, terms version and age check as the create page, and the person lands on the grant question for the same request, signed in. Until the deployment sets it, such a person is sent to the sign-in page, which links to the create page and also comes back to the same request. Off. Production receives it after the sandbox, with no date. Nothing in your client: the authorization request, the redirect and the code exchange stay as they are. Send the person the request once and leave it as it is: a request that changes between the page and the person's return is refused with access_denied. planned
Flags LIFECAREID_SEPARATE_CLIENT_SESSIONS is off, so the session a client receives at /token acts as the person on the issuer's own pages and on the routes that act as the person, as it always has. With it on, that session never counts on the issuer's own pages (/authorize, the grant question and its answer, the email question and its answer, the session handoff) or on the recovery email routes, and counts on the panel, the consent, rights and registry routes, POST /v1/token and introspection's user answer only for a client named in LIFECAREID_PERSON_SESSION_CLIENTS. For any other client those routes answer as they answer a session that was never issued: 401, or active: false from introspection, or the sign-in page. The test identity's session is the person's own and keeps working. The setting needs LIFECAREID_REQUIRE_CALLER_AUTH on: the issuer does not start with it on and caller authentication off. Off. The sandbox turns it on one full session lifetime after its pin carries this release, with no clients named; production turns it on after its release, naming the operator's own apps, before data requests are switched on. Nothing today. Use the session your client receives to know who signed in (did, /userinfo), not to act as the person; act as a synthetic person with the test identity's session, and take your data token from the authorization code flow. Then nothing changes for you when the setting is turned on. same
Flags No rate limits today (LIFECAREID_RATE_LIMITS is off, its default). Enforced. A burst can be answered 429. Handle 429 and back off. production-only
Flags LIFECAREID_SANDBOX is on. It mounts the four sandbox routes as live; it also adds your registered redirect URIs to the page security policy, a note to the consent page that the person is synthetic, and one sentence to the create and sign-in pages. On a sandbox the passkey ceremony runs only when the relying-party ID is the sandbox's own host; otherwise its begin routes answer 503. Off. The routes answer 404, the page security policy adds no registered redirect URIs, and the consent page and the create and sign-in pages carry no note. Nothing. sandbox-only
Flags Demo sessions are off (LIFECAREID_DEMO_SESSIONS). On, for the public product demo: POST /v1/demo/session mints a throwaway passkey-free identity. It is not a route for an app. Nothing; do not build on it. production-only
Flags The node key registry (LIFECAREID_NODE_KEYS) is empty, so GET /v1/node-keys returns an empty list. The operator declares the signing keys of its nodes there. Nothing. production-only
Flags Developer access: the four sandbox routes need a developer access token (LIFECAREID_DEVACCESS_SECRET verifies it), minted at the portal on the production host. The sandbox's own /devaccess redirects there (LIFECAREID_DEVACCESS_PORTAL_URL). Nothing in the production API needs the token. Drop the developer access token from your production calls. sandbox-only
Routes /v1/sandbox/clients (POST, with the developer access token as Bearer). Answers 404. It is outside the published contract. Remove it from your production code path. sandbox-only
Routes /v1/sandbox/clients/{client_id} (GET and DELETE, with the client's id and secret as HTTP Basic plus the developer token as the lc_dev cookie). Answers 404. It is outside the published contract. Remove it from your production code path. sandbox-only
Routes /v1/sandbox/test-identity (POST, developer token as Bearer). Answers 404. It is outside the published contract. Remove it from your production code path. sandbox-only
Routes A page on another origin can fetch the RFC 8414 document, the OpenID configuration and the JWKS, and call /token and /revoke: those five routes send Access-Control-Allow-Origin: * and answer an OPTIONS preflight with 204. /authorize, /v1/sandbox/* and introspection send none. The issuer sends no CORS headers. Production waits for a ruling before any change. Keep the code exchange on a backend you run; a browser-based client works against the sandbox only. sandbox-only
Issuer The issuer is https://sandbox.lifecare.id (LIFECAREID_OIDC_ISSUER). The passkey ceremony accepts the sandbox origin alone (LIFECAREID_EXPECTED_ORIGIN), and its relying-party ID is sandbox.lifecare.id. The session cookie is host-only, so it reaches no other host. The issuer is https://app.lifecare.id, the ceremony accepts the app origin, and the relying-party ID is lifecare.id. The session cookie is host-only on both; the cookie domain .lifecare.id (LIFECAREID_COOKIE_DOMAIN) is used on both for the developer access cookie alone. Change the issuer URL in your configuration and read endpoints from its discovery document. operator
Issuer The contract is 0.30.0. The contract is 0.24.1 today. Production receives later releases on its own schedule, so a route or field that exists in the sandbox can be missing in production for a while. Check the published contract of the deployment you target. planned

What is identical

The promotion checklist

  1. Ask the operator for a production client. Give the same redirect_uris you registered in the sandbox, and say whether the app can keep a secret.
  2. If you run a server that reads on a person's behalf, ask the operator to put its resource on the allow-list. Until a proof of control exists, expect to be asked how you control the URL.
  3. Change the issuer URL in your configuration, and read the endpoints from the discovery document of that issuer.
  4. Replace the synthetic session with the person's real passkey sign-in. The data token still comes from the authorization code flow, never from POST /v1/token with a session. If you walked the passkey path on the sandbox, your code stays as it is; the relying-party ID differs (sandbox.lifecare.id on the sandbox, lifecare.id in production), so a person's sandbox passkey does not sign in to production and they use their production one.
  5. Keep your token handling and your receipt handling as they are. Build to the sandbox's access-record rule; production receives it with its next release.
  6. Remove everything that calls /v1/sandbox/*, and drop the developer access token. Handle 429 if you did not already.
  7. Before you rely on a data scope, check that the deployment you call has data scopes switched on (see the flags in the table).

Nothing else changes.

What breaks if you skip this