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 handlers. Grant, revoke, token, introspection and the ledger are one code base on both; production runs an earlier release of it today (sandbox 0.30.0, production 0.24.1), so a change can reach the sandbox first, and behaviour added since the production release is marked
plannedin the table. The sandbox's four extra routes, and the CORS headers on five issuer routes (the Routes row above), are the only surface it adds. - The tokens. A session token is
lcs_; a data-access token islc_, opaque and stored hashed; both have the same lifetimes (1200 seconds for a data token). - The receipt:
consent_idandledger_entry_hash. - Introspection: it needs your client credentials, and a person's session in their place is
403. - Person-managed authorization, with LifeCare.ID® as its first implementation, wherever data scopes are on (in production that is
planned): the person answers the question on the LifeCare.ID® origin, one data scope per token, the audience inaud.
The promotion checklist
- Ask the operator for a production client. Give the same
redirect_urisyou registered in the sandbox, and say whether the app can keep a secret. - 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.
- Change the issuer URL in your configuration, and read the endpoints from the discovery document of that issuer.
- 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/tokenwith a session. If you walked the passkey path on the sandbox, your code stays as it is; the relying-party ID differs (sandbox.lifecare.idon the sandbox,lifecare.idin production), so a person's sandbox passkey does not sign in to production and they use their production one. - 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.
- Remove everything that calls
/v1/sandbox/*, and drop the developer access token. Handle429if you did not already. - 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
- A script that obtains a token for an app by calling the API path with a session, instead of taking the authorization code flow, is refused
403: a session is issued a token only over the person's own grant, never over a third party's grant, and a grant that names your app is a third party's. - Where data scopes are on, a client whose resource is not on the operator's allow-list is refused at the resource check:
/authorizeredirects witherror=invalid_target, and no person is asked. - A script that sends no credential on grant, token, ledger, grants or revoke is refused
401. On the sandbox thedetailnames the session it expected; production's current release words it without the session, naming the signature and client credentials.