Client-ID metadata documents: how the issuer admits an agent
Status: the policy on this page is ruled (D-AI3, 2026-11-05). The LifeCare.ID® issuer accepts client-ID metadata documents under these rules on the sandbox (live, AI-SANDBOX-CIMD), and production follows (gated, AI-PROD-CIMD). Every rule below describes what the issuer does, and this page says where each part is live.
An AI assistant that reaches a data source naming LifeCare.ID® as its authorization server has to say who it is before a person is asked anything. This page is the text the issuer will be built to, so that a developer, or the coding agent building for one, can read in advance what is admitted and what is refused. It is part of person-managed authorization: the person decides, on the LifeCare.ID® origin, and the client's identity is only the first question.
What a client-ID metadata document is
A client-ID metadata document (CIMD) is a JSON document published at an HTTPS URL. The client uses that URL as its client_id. The issuer fetches the document, reads the client's name and redirect URIs from it, and needs no registration call. The document is specified in an IETF Internet-Draft, draft-ietf-oauth-client-id-metadata-document (revision -03 when this page was written). It is a draft, not a final specification, and it can change.
The Model Context Protocol authorization specification, revision 2025-11-25, says authorization servers and MCP clients should support CIMD, and keeps dynamic client registration (RFC 7591) as an optional path for backward compatibility. Both ChatGPT apps and Claude connectors document support for CIMD (status: documented by each platform, not checked by this page).
A client reaches LifeCare.ID® now in one of two ways: a sandbox client created through the self-service routes, or a production client the operator provisions (From sandbox to production). CIMD is the third route on the sandbox, so that a stranger's assistant can connect with no prior step.
The fetch rules the issuer will apply
Status: ruled, live on the sandbox. When a request arrives with an HTTPS client_id, the issuer fetches the document and apply the draft's rules:
- The
client_idmust be an HTTPS URL, and it must equal the document's ownclient_idvalue exactly. - The answer must be HTTP 200. The issuer follows no redirect.
- The issuer reads at most 5 kilobytes of the answer, the draft's recommended limit, and refuses a document that is not complete by then.
- The issuer never fetches an address that is special-use (RFC 6890), on the sandbox or in production. Only a local development copy running on loopback may fetch from that same loopback interface, as the draft allows. The hosted sandbox is not on loopback.
- The document names its authentication method as
token_endpoint_auth_methods_supported(an array, the draft's preferred form) ortoken_endpoint_auth_method(the singular, still read). At least one must be present, and whichever is present allows onlynoneandprivate_key_jwt. A document that allowsprivate_key_jwtcarries a key set:jwksinline, orjwks_uri(see Authenticating with a key set). Status: live on the sandbox. - The connect and each read may take 3 seconds. The whole fetch is held to 6 seconds by one limit that covers the DNS lookup, the connection, the TLS handshake, the response headers and the body, so a server that answers slowly cannot hold it longer. The issuer runs at most 8 document fetches at once and refuses a ninth at once (
the issuer is fetching too many client metadata documents just now: try again shortly). - The sandbox also accepts an
httploopback redirect URI (localhost,127.0.0.1or[::1]) in the document, and matches it with the port ignored, as the draft allows (section 4.2), so a local coding agent can walk the sandbox. Production accepts none (the redirect rule below). - A document that names neither authentication field is refused, although the draft reads an absent field as
none: the sandbox asks for an explicit statement. - The issuer resolves the host and checks every address it returns, then connects to the address it checked, so a second DNS answer cannot move the fetch. The answer must be served as
application/json. - The issuer keeps the parsed document for the time the answer's
Cache-Control: max-agegives, never less than 60 seconds and never more than 24 hours. An answer with nomax-ageis kept for 300 seconds, andno-storeorno-cacheis read as the 60-second floor. A document is fetched again only after that time. A cached copy is used until its time ends, and an expired copy is never used when a new fetch fails. - A document that fails any rule is refused, and no person is asked anything.
The terms every admitted client gets
Status: ruled (D-PL3, 2026-11-03), live on the sandbox. A client admitted through a CIMD has these terms, with no exception for a platform:
- PKCE with the
S256method. A request without it is refused. - No shared secret. The client holds none and the issuer sends none. A document-carried key set may authenticate the client at the token endpoint with
private_key_jwt(live on the sandbox); a document that does not declare it sends no credential and PKCE is the proof. - The person's yes is rendered only on the LifeCare.ID® origin, never by the client.
- The redirect URI is matched exactly, as a string, against the document's
redirect_uris. The sandbox also accepts anhttploopback redirect (localhost,127.0.0.1or[::1]) with the port ignored; production accepts no localhost or loopback redirect. - No refresh token is issued. The grantee is the
client_idthe code was issued to, and a token presented by any other client is refused. - The access token lasts 1200 seconds, as for every data token. For an assistant used through a day this means the person is sent back to the LifeCare.ID® origin each time a token ends. That friction is kept on purpose and will be measured in the first sandbox walk by a stranger. It is not changed by this policy.
The ceiling: tier T0
Status: ruled, live on the sandbox. Every CIMD client is admitted at the lowest ceiling, T0 (D-AG6b): the same unreviewed, read-only, short-lived ceiling that Agent trust (developer access) gives a resolvable agent. A CIMD client is not on that ladder, because it has no registered DID or manifest. At T0:
- A request that asks for no data scope, a sign-in alone, is refused: a CIMD client receives a data token only.
- One data scope at a time, with the
resourcethe token is for. A request for two scopes, or with noresource, is refused. - Interpreted outputs only. No raw biometric value is offered at any tier.
- A short expiry, the 1200 seconds above.
- The consent page shows the client's hostname, taken from its fetched document, and the words "not reviewed" unless the operator named the host, so the person reads who is asking before answering. Showing the hostname is how the issuer answers a client that claims to be a known assistant: a CIMD
client_idis a URL on the client's own domain, and a client cannot present a platform's hostname without controlling it. - The asker line. Status: live on the sandbox. The page then says "An app or AI assistant is asking:
at ", or "An app or AI assistant at is asking" when the document has no name; the heading names the client with its hostname too. The issuer cannot tell an assistant from an app, so it says both. Right after it the page says "Not reviewed by LifeCare.ID®. Anyone may register a client this way. You decide whether it may read what it asks for.", or for a host the operator named " is a platform the operator has named.", and the tier: "This client is at the lowest ceiling: one data scope, interpreted outputs, tokens that last 20 minutes." - The hostname is the only address shown, as plain text and not a link, and the document URL is not printed. The page never says "verified", "trusted" or "approved" about a client and carries no badge or seal. Only the person says yes, on the LifeCare.ID® origin.
What the issuer accepts and refuses
Status: ruled, live on the sandbox.
| The issuer accepts | The issuer refuses |
|---|---|
An HTTPS document whose client_id equals its URL, answered with HTTP 200, no redirect, read within 5 kilobytes |
A redirect, any answer other than 200, an oversize document, a special-use address |
| An exact redirect-URI match, including the callback URLs a platform documents for its own client | A localhost or loopback redirect in production |
| PKCE S256, no shared secret, the yes on the LifeCare.ID® origin, no refresh token | A request with no resource, or with two data scopes |
A document that allows none, private_key_jwt or both, and for private_key_jwt carries a jwks or a jwks_uri with an RSA, EC P-256 or Ed25519 public key (live on the sandbox) |
Any other method (client_secret_basic, client_secret_post, client_secret_jwt), a private key parameter in a key set, an assertion signed with none or an HMAC algorithm, a replayed jti |
| Any such client at the T0 ceiling, with its hostname and "not reviewed" on the consent page | Anything above T0 from a client the operator has not admitted, until the trust list can vouch |
| A platform hostname the operator has named once | A token presented by anyone but the client it was issued to |
Authenticating with a key set
Status: ruled (D-AI3 as amended 2026-11-05); live on the sandbox. A client whose document allows private_key_jwt and carries a key set may prove itself at the token endpoint with a signed assertion (RFC 7523, RFC 7521 section 4.2) instead of sending no credential. Every other term on this page is unchanged: PKCE S256, exact redirect match, no refresh token, one data scope, the 1200-second token, the T0 ceiling.
A token request carries client_id, then what the document declares. A document that declares private_key_jwt (alone or beside none) requires client_assertion_type=urn:ietf:params:oauth:client-assertion-type:jwt-bearer and client_assertion, as the client-ID metadata draft asks (section 5), and a request with no credential is refused. A document that allows only none sends nothing more. The document's declaration decides, not the request. The issuer verifies the assertion like this:
- The signature is checked against the document's key set, picked by the header
kid(or the single key). The algorithm isRS256,ES256orEdDSAand must fit the key;noneand every HMAC algorithm are refused. issandsubequal theclient_idURL.audis a single value: the issuer identifier (theissuerin the issuer's metadata). The token endpoint URL is also accepted as a lone value, for clients written to RFC 7523 before the issuer-identifier rule; new clients use the issuer identifier. A list with more than one value, or any other audience, is refused.- If the header carries
typ, it isJWT(orjwt). expis present, in the future and at most 5 minutes ahead.iat, when present, is within 5 minutes of the issuer's clock.jtiis required and is single use until the assertion expires. The issuer keeps at most 10,000 spent values, 256 for any one client, 512 for any one client host, and refuses a new assertion rather than forget an old value.- The assertion is at most 4096 bytes. A
client_secretor a Basic header is refused as before.
The issuer's discovery documents now list private_key_jwt in token_endpoint_auth_methods_supported, and the algorithms in token_endpoint_auth_signing_alg_values_supported, on the sandbox.
Naming a platform, and rising above T0
Status: ruled, live on the sandbox. The operator names a platform's hostname once, in the issuer setting LIFECAREID_CIMD_NAMED_PLATFORMS (a comma-separated list of hostnames, empty by default and empty on the sandbox). A client on a named hostname is shown to the person by that hostname without "not reviewed". Naming a platform adds no scope and raises no tier by itself (this page's reading of D-AI3). ChatGPT's own document (fetched 2026-11-05) lists none and private_key_jwt and carries a jwks_uri; the issuer admits it now, and naming chatgpt.com takes effect now. What the tier line on the consent page reads for a named platform is defined with the consent page's agent lines (AI-CONSENT-AGENT-LINES).
A client rises above T0 only through the operator, until the trust list (D-AT5) can vouch for it. The operator's runbook for naming a platform and lifting a client, with the log of each such decision, is written (2026-11-05); the first naming act follows the operator's word, and this page says when a platform is named. Until a voucher exists, the operator is the one route above T0. The tiers and the vouching idea are on Agent trust (developer access). Two further rungs, tested and withdrawn, are adopted (D-AT3) and arriving, and will be added to that page.
What is not offered
Status: ruled (D-AI3, D-AI12).
- No dynamic client registration. MCP keeps it for backward compatibility, and neither platform prefers it. The sandbox self-service routes stay sandbox-only, and production does not open registration to the public.
- No delegation chains. A token is used only by the client it was issued to, for its one
resource, and is never passed on (MCP forbids token passthrough). A recorded chain of agents is reserved for a later profile draft. - Software statements are reserved. RFC 7591 allows a statement from a trusted attester. Under the ladder that attester would be a voucher, so the option is reserved in the profile and waits for the first voucher.
- No badge, seal or ranking. Admission at T0 says only that the document passed the fetch rules. It is not an endorsement, and the consent page says "not reviewed" for that reason.
The handoff the client must support
Status: ruled (D-AI11). The sandbox redirects a registered client to /authorize on the LifeCare.ID® origin now. The consent page's agent lines (AI-CONSENT-AGENT-LINES) are live on the sandbox. The QR code and the device grant (AI-DEVICE-GRANT-NOTE) are planned, with the sandbox first. The person answers on the LifeCare.ID® origin, so the client has to get them there:
- A same-device link first, opened in the person's own browser.
- A QR code for another device when the person is on a different one.
- The device authorization grant (RFC 8628) where the client cannot host a redirect, as with voice.
The device page and the consent page say what is authorized and who asked, and say that an app or AI assistant is asking. The passkey ceremony carries user verification in production. The assistant never renders, proxies or answers the consent question, and never holds the person's key.
A minimal document
The values below are placeholders. Replace them with your own. The document must be served at the URL in client_id, over HTTPS, with no redirect.
{
"client_id": "https://assistant.example/lifecare-client.json",
"client_name": "Example assistant",
"client_uri": "https://assistant.example",
"redirect_uris": ["<the callback URL the platform documents>"],
"grant_types": ["authorization_code"],
"response_types": ["code"],
"token_endpoint_auth_method": "none",
"token_endpoint_auth_methods_supported": ["none"]
}
If your client is your own agent, the template in A template to copy is the document to write. If your client is a platform, read When the client is a platform first.
A template to copy
Status: the sandbox accepts a document like this one (live, AI-SANDBOX-CIMD); production follows, gated (AI-PROD-CIMD). The file is published, as strict JSON, at https://developers.lifecare.id/client-id-metadata.example.json. JSON has no comments, so each field is explained below.
This template is for a developer's own agent: a client that runs on the developer's own domain and receives its own callback. A person who uses ChatGPT or Claude is served by that platform's own document, described in the next section, and a developer's MCP server behind a platform needs no document of its own for it. Copy the file, replace every value that names assistant.example, and serve it at the address you put in client_id.
| Field | What to put there | The rule the issuer will apply |
|---|---|---|
client_id |
The HTTPS address the file is served at, exactly. | Must be an HTTPS URL with a path, and must equal the document's own address byte for byte. Answered with HTTP 200 and no redirect. |
client_name |
The name of your assistant, as a person would say it. | Shown to the person with the hostname of client_id. A name does not stand in for the hostname. |
client_uri |
The home page of the client, on the same origin as client_id. |
Read as information only. |
redirect_uris |
Your own callback addresses, each over HTTPS and on your origin. | Matched exactly, as a string. The sandbox also accepts an http loopback address (localhost, 127.0.0.1 or [::1]) and ignores the port; production accepts no localhost or loopback address. |
token_endpoint_auth_method |
none, or private_key_jwt if the client signs an assertion. |
The client holds no shared secret. Any other value is refused. |
token_endpoint_auth_methods_supported |
["none"]. |
The draft (revision -03, section 4.1) asks a client to publish the array, and marks the singular field above as kept for older readers. The template carries both. The issuer reads both, and whichever is present allows only none and private_key_jwt. |
jwks or jwks_uri (optional, needed for private_key_jwt) |
A JWK Set with your public keys inline, or an HTTPS address that serves it. Public parameters only. | RSA (2048 bits or more, RS256), EC P-256 (ES256) or Ed25519 (EdDSA); kid on each key when there is more than one. At most 16 keys. A jwks_uri is fetched under the document's own rules with a limit of 16 kilobytes, within the same 6-second limit as the document, and is kept as long as the document. When an assertion names a kid the kept set lacks, the issuer fetches the set once more (at most once a minute per address), so a rotation does not wait for the cache. Carry one of jwks and jwks_uri, never both (the draft's rule); a document with both is refused. The inline set counts toward the document's 5 kilobytes. |
grant_types |
["authorization_code"]. |
The code flow with PKCE S256 is the one flow admitted. A client that will use the device grant adds urn:ietf:params:oauth:grant-type:device_code when that grant lands (The device grant). |
response_types |
["code"]. |
As for grant_types. |
scope |
One data scope. The template uses daily. |
At the T0 ceiling, one data scope per token, with the resource the token is for. |
contacts |
An address where the issuer's operator can reach the person who runs the client. | Read as information only. |
The issuer will read at most 5 kilobytes of the answer; the template is well under that. The published template allows none; a client that signs an assertion changes the two method fields and adds a key set, as the table says.
logo_uri is left out on purpose. The consent page shows no logo or badge for a client, because a picture next to a request reads as approval, and admission at T0 says only that the document passed the fetch rules (D-AI12).
When the client is a platform
Status: ruled (D-AI3, D-AI7, 2026-11-05), live on the sandbox. A client-ID metadata document identifies the OAuth client. When a person uses ChatGPT or Claude, the platform is the client and presents its own document, with its own redirect address. A developer writes no document for a platform's client. What the issuer will see from each platform, from the platform's own page, is:
- ChatGPT: https://developers.openai.com/apps-sdk/build/auth, fetched 2026-11-05. The page gives the platform's own document at
https://chatgpt.com/oauth/client.json, and its redirect addresshttps://chatgpt.com/connector_platform_oauth_redirect, for a server whose authorization server meets RFC 9207 issuer identification. For other servers it gives a per-connection form of each,https://chatgpt.com/oauth/{callback_id}/client.jsonandhttps://chatgpt.com/connector/oauth/{callback_id}, with the exact address on the connection's management page. ChatGPT's document, fetched 2026-11-05, listsnoneandprivate_key_jwt, namesRS256, and carries ajwks_uri; the issuer admits it now. The LifeCare.ID® sandbox issuer's metadata advertisesauthorization_response_iss_parameter_supported: true(checked 2026-11-05 at https://sandbox.lifecare.id/.well-known/oauth-authorization-server), so the stable pair is the one expected. - Claude: https://claude.com/docs/connectors/building/authentication, fetched 2026-11-05. For the hosted Claude apps (claude.ai on the web, Desktop, mobile, Cowork) the page says the redirect address is exactly
https://claude.ai/api/mcp/auth_callback, and that Claude identifies itself with a document Anthropic hosts. For Claude Code the page gives a document athttps://claude.ai/oauth/claude-code-client-metadatathat declares loopback redirects (http://localhost/callbackandhttp://127.0.0.1/callback, port ignored). Production refuses a loopback redirect, so that document is for the sandbox and local development only.
These are the hostnames the operator may name under D-AI3 (Naming a platform, and rising above T0). Until the operator names one, the platform's client is admitted like any other, at T0 and "not reviewed". Both platforms can change an address, so check the page again before you rely on it.
Refusal errors
Status: defined by the sandbox implementation, live on the sandbox.
A refusal at /authorize is shown to the person as an error page with HTTP 400 and a JSON body, and is never a redirect: the redirect URI is the thing the issuer has not verified. A refusal at /token is invalid_client (HTTP 401) or the error named below, always an RFC 6749 section 5.2 error object (error and error_description and nothing else); the full table is on Authorization and tokens. A refusal that is about the network or the issuer's load and not about the document (the host did not resolve, the timeout, a refused or dropped connection, too many fetches) is HTTP 503 with temporarily_unavailable and Retry-After, so a client keeps its state and tries again. A certificate that fails verification is the client's to fix and stays 401 invalid_client. At /authorize, too many fetches is also HTTP 503 with Retry-After; the other document refusals there are HTTP 400. At /authorize the body is {"error": ..., "error_description": ..., "detail": ...}, and detail repeats the description. These are the exact error_description strings.
Status: live on the sandbox. At /token the body is {"error": ..., "error_description": ...} with no detail, and every 401 invalid_client carries WWW-Authenticate: Basic realm="lifecare.id" (RFC 6749 section 5.2).
When the client document is refused (error is invalid_client):
the client_id is not a usable client metadata document URL: use an HTTPS URL with a path, no fragment, no credentials and no dot segmentsthe client metadata document host is not ASCII(write an internationalized host in its punycode form,xn--...)the client metadata document host did not resolvethe client metadata document host resolves to a special-use address, which this issuer never fetchesthe client metadata document could not be fetched in timethe client metadata document could not be fetched: the connection or its certificate failedthe issuer is fetching too many client metadata documents just now: try again shortlythe client metadata document answered a redirect, which this issuer does not followthe client metadata document did not answer HTTP 200the client metadata document is larger than 5 kilobytesthe client metadata document is not served as application/jsonthe client metadata document is not a JSON objectthe client metadata document client_id does not equal its URLthe client metadata document needs redirect_uris, a list of URLsthe client metadata document has a redirect URI that is not HTTPS or that names localhost or a loopback addressthe client metadata document must allow only none or private_key_jwt as its token endpoint authentication methodthe client metadata document allows private_key_jwt but carries no key set: add jwks or jwks_urithe client metadata document carries both jwks and jwks_uri: keep onethe client metadata document jwks_uri is not a usable HTTPS URLthe client key set is larger than 16 kilobytes- For the
jwks_urifetch, the same refusals as the document's, naming the key set:the client key set host did not resolve,the client key set host resolves to a special-use address, which this issuer never fetches,the client key set could not be fetched in time,the client key set could not be fetched: the connection or its certificate failed,the client key set answered a redirect, which this issuer does not follow,the client key set did not answer HTTP 200,the client key set is not served as application/json the client key set is not a JSON Web Key Set with at least one public keythe client key set carries a private key parameter, which is never acceptedthe client key set holds no usable RSA, EC P-256 or Ed25519 signing key, or a key lacks the kid a multi-key set needsthe client metadata document grant_types must include authorization_codethe client metadata document response_types must include code
When the request breaks a term:
- At
/authorize,invalid_request:redirect_uri does not match a redirect_uris entry in the client metadata document - At
/authorize,invalid_request:PKCE with the S256 method is required - At
/authorize,invalid_scope, sent to the verified redirect URI:a client identified by a client metadata document asks for exactly one data scope(a request with two data scopes carriesone data scope per token: ask for each data scope in its own request) - At
/authorize,invalid_target, sent to the verified redirect URI, whenresourceis missing, repeated or not one this issuer serves - At
/token,invalid_client(HTTP 401):a client identified by a client metadata document holds no secret: send none - At
/token,invalid_client(HTTP 401), for an assertion: client_assertion_type must be urn:ietf:params:oauth:client-assertion-type:jwt-bearer and client_assertion must be presentthe client metadata document does not allow this client authentication methodthe client metadata document allows private_key_jwt: send a client_assertionthe client assertion is not a signed JWT this issuer accepts: use RS256, ES256 or EdDSA, and a typ of JWT if you send onethe client assertion was not signed by a key in the client metadata documentthe client assertion needs iss and sub equal to the client_id, aud naming this issuer's identifier as its only value, exp within 5 minutes and a jtithe client assertion has expired or is not yet validthe client assertion jti was already used- At
/token, HTTP 503temporarily_unavailable:the issuer is holding too many client assertions just now: try again shortly - At
/token,unauthorized_client(HTTP 400):a client identified by a client metadata document receives no refresh token - At
/token,invalid_grant(HTTP 400):this client receives a data-access token only(a guard:/authorizealready refuses a request with no data scope) - At
/token,invalid_grant(HTTP 400):the authorization code is unknown, already used or expired, or was issued to another client or redirect_uri: start the flow again, andPKCE verification failed - At
/token,invalid_request(HTTP 400):code_verifier is required(and the same forcode,redirect_uriandgrant_type); the code is not spent - At
/token,unsupported_grant_type(HTTP 400):grant_type must be authorization_code (or refresh_token for a native client)
A client sends its client_id in the form body and no Authorization header. The issuer does not read a URL client_id from HTTP Basic, and a Basic header or a client_secret is refused with 401 invalid_client for a CIMD client, because it holds no shared secret. That answer carries WWW-Authenticate: Basic realm="lifecare.id" like every 401 from /token, as RFC 6749 section 5.2 asks, although Basic is not a method a CIMD client can use. The token answer names the audience: resource is in the success body beside access_token, token_type, expires_in and scope. Status: live on the sandbox.
Where this is going
The profile that specifies person-managed authorization carries this policy in its first draft, planned for 2026-12-01 (status: planned). The page for the authorization flow itself is Person-managed authorization, and the differences between the sandbox and production are on From sandbox to production.
Sources checked
Fetched on 2026-11-05, each answering HTTP 200:
- Model Context Protocol, Authorization, revision 2025-11-25: https://modelcontextprotocol.io/specification/2025-11-25/basic/authorization
- OAuth Client ID Metadata Document, IETF Internet-Draft: https://datatracker.ietf.org/doc/draft-ietf-oauth-client-id-metadata-document/
- RFC 7591, OAuth 2.0 Dynamic Client Registration Protocol: https://www.rfc-editor.org/rfc/rfc7591.html
The statements about what ChatGPT apps and Claude connectors support come from each platform's documentation and are unverified by this page [unverified]. Check them there before you rely on them.
For coding agents
If you are an agent building a client for a LifeCare.ID® issuer, follow these lines. They describe the ruled policy, and the sandbox page lists what is live.
- Build to For coding agents with a registered client (there, a data scope goes to a client that holds a secret); switch to a client-ID metadata document once this page lists the sandbox as live.
- Publish an HTTPS client-ID metadata document and use its URL as the
client_id. - Make
client_idin the document equal the URL it is served at. Serve it with HTTP 200, no redirect, within 5 kilobytes. - On any refusal from
/token, read theerrormember of the JSON body first (invalid_client,invalid_grant,invalid_request,invalid_target,unsupported_grant_type,unauthorized_client,temporarily_unavailable) and act on it as RFC 6749 section 5.2 says;error_descriptionis a sentence for you to log, and there is nodetailmember. On success, readresourceto see which source the token is for. Status: live on the sandbox. - Use PKCE with S256. Hold no shared secret. Set
token_endpoint_auth_methodtonone, or toprivate_key_jwtwith ajwksorjwks_uriin the document (the document's declaration decides: a document that declaresprivate_key_jwtrequires the assertion on every token request). - To sign an assertion: generate an RSA 2048, EC P-256 or Ed25519 key pair and publish only the public half, with a
kid, in the document's key set. - Build a JWT with
issandsubequal to yourclient_id,audequal to the issuer identifier as its only value,expat most 5 minutes ahead and a new randomjti. - Sign it with
RS256,ES256orEdDSA, put thekidin the header, and never usenoneor an HMAC algorithm. - Send it as
client_assertionwithclient_assertion_type=urn:ietf:params:oauth:client-assertion-type:jwt-bearerand yourclient_idin the form body. Make a new assertion for every request. - List the exact redirect URI. Send it byte for byte. Use no localhost or loopback redirect in production.
- Ask for one data scope and one
resourceper token. - Expect no refresh token. When the 1200-second token ends, send the person back to the LifeCare.ID® origin.
- Expect the person's yes on the LifeCare.ID® origin. Never render, proxy or answer it, and never hold the person's key.
- Use the token only as the client it was issued to, at its one
resource. Never pass it on. - Expect the T0 ceiling and "not reviewed" beside your hostname. Do not ask for more.
- Do not register dynamically, pass the token on or present a software statement.
- Hand the person off by a same-device link, a QR code, or the device grant.