Sign-in, sessions, and tokens #
On this page
A credential identifies the account, application, or user making a request. Browsers, AI tools, unattended jobs, and running applications use different credentials with different permissions and lifetimes.
Compare credentials #
For your Turn Zero account #
| Credential | Used by | May do | Presented as | Lives | Ended by |
|---|---|---|---|---|---|
| The browser's cookies | you, in a browser | the signed-in site and the actions its pages use. A dashboard change needs a sign-in in the last 8 hours, and only a browser approves a destructive action | cookies on the platform origin | the site, dashboard, application programming interface (API), and support cookies 30 days from your last visit, 90 days at most from the sign-in; the approval cookie 8 hours | Sign out in that browser, Sign out everywhere, suspension, erasure, a passkey change's revert, expiry |
| The AI tool's connection, signed in through the browser | your MCP client | every action open to your account; a destructive one waits for your approval in a browser | an OAuth access token, a bearer on the MCP endpoint | 30 days, renewed through a refresh token that lasts 30 days longer | Sign out everywhere, revoke_token with connection, the tool's own revocation, suspension, erasure, a passkey change's revert, a replayed refresh token, 60 days without renewal |
| A device sign-in to the Turn Zero connection | an MCP client on a computer without a browser | tzTrack and limited account and documentation tools; no Cloud management or data services (Device sign-in limits) | an OAuth access token, a bearer on the MCP endpoint | the access token 30 days; the refresh token 60 days, renewed as The tool's connection describes | the same events that end an AI tool's connection |
| A minted token | a script, a pipeline, a contractor's tool | the actions of its scope, the whole account or one application, with only the grants its minting session had and asked for. A destructive one needs the destructive grant and your approval in a browser. It cannot mint another token | a bearer on the HTTP API, the MCP endpoint, or the storage, logging, and egress endpoints, with the environment header | no expiry by default; optionally 1–3650 days from minting | revoke_token, expiry, erasure, deletion of the application it is bound to. |
| A product token, a minted token for one of Turn Zero's own products | your MCP client, connected to that product's own MCP endpoint | that product's service as your account, and on this platform list_tokens, the public reads, and the few other actions its product's grant names. Other account actions refuse it with 403 tzmesh_bounded for tzMesh or tztrack_bounded for tzTrack |
a signed bearer on the product's endpoint, which the product's service checks against the key set this platform publishes for it, with no call back here | 180 days from the sign-in; no renewal, so you sign in again after | revoke_token, expiry, erasure, the removal of the product from your account, and the platform's revocation of that product's signing keys. A token a sign-in minted also ends at Sign out everywhere, a passkey change's revert, a later sign-in by the same client under the same label, and a suspension. A minted one is only refused while a suspension stands. The product's service applies each within about a minute |
For applications and their users #
| Credential | Used by | May do | Presented as | Lives | Ended by |
|---|---|---|---|---|---|
| The platform credential | your deployed backend | your backend's calls to its own environment's storage, logs, egress gateway, and verification route, and its email and push sends, with no environment named; of the management actions, read_account alone |
TURNZERO_CLOUD_APP_TOKEN, a bearer on the platform's own endpoints |
until its environment gets a new value | a new value: in production at every deploy to production and every promote, in development through store_secret with replace: true on the development scope; the environment's or the application's deletion, the account's erasure |
| An egress key | your deployed backend's provider SDK | calls to its one upstream through the egress gateway, and nothing else on the platform | the setting an upstream's sdk_settings names as its key, a bearer on that upstream's egress route alone |
until the environment's next deploy, promote, or restart_application replaces the copy that contains it |
that replacement, the failed deploy or promote that minted it, a re-declaration whose sdk_settings is null or has no key, declare_outbound_api with remove: true, the environment's or the application's deletion, the account's erasure |
| An end-user session | your application's users | your application's routes as that user; no management action | the cookie __Host-turnzero_cloud_realm on the application's own hostname, containing a signed token |
the token one hour, issued again while the session lasts its realm's session length, 30 days by default | the user's sign-out, the user's ending of it from the session list, set_end_user_standing's suspension, delete_end_user, revoke_app_sign_in_keys, the realm's end |
| A native app's session | the users of your mobile app | your application's routes as that user; no management action | the same signed token as a bearer in the Authorization header, with a refresh credential the app keeps |
the token one hour; each refresh extends the session by the realm's session length, up to session_cap_days from the sign-in, 365 days by default |
the app's revocation call or its sign-out, POST /__account/signout under the bearer, an ending from the session list, a refresh credential replayed after sixty seconds, set_end_user_standing's suspension, delete_end_user, revoke_app_sign_in_keys, the cap, the realm's end |
For commands and one-time access #
| Credential | Used by | May do | Presented as | Lives | Ended by |
|---|---|---|---|---|---|
| An authorized computer's token, a minted token | the turnzero command on that computer, read from its credential file | every action an account-scoped minted token with no grant may call, from any computer. The command runs its turnzero deploy, turnzero check, turnzero promote, turnzero library take, turnzero scaffold, turnzero session, turnzero logout, turnzero whoami, and turnzero run --sign-in lines under it. It also runs its turnzero provision lines and its turnzero secret lines that pipe no grant (This computer's token) |
a bearer on the HTTP API, sent to the origin it was minted for | 30 days at most from minting by your turnzero login, or by authorize, which your signed-in AI tool runs itself and then tells you about; authorizing the computer again renews it |
revoke_token, the command's turnzero logout, expiry, erasure. It works from any computer until then |
| A token code | the turnzero command, from a mint_token line or the platform's sign-in page for the CLI, /approve/computer. Ordinary login receives a callback or pasted code. With login --device, the platform holds approval while the requesting computer polls |
minting the one token its mint_token call or browser approval set up, once |
a bearer on mint_token on the HTTP API, once, with the saved verifier, or the verifier as bearer with the mint's id. Device polling sends the saved verifier as the bearer and mint: device in the request. The platform hashes the verifier to obtain the challenge. The code stays on the platform |
normally until expires_at, five minutes at most, and never past its minting session's end. Device approval lasts an hour from approval, never past the approving session's end; the pending request must also remain valid |
one use, expiry, account suspension or erasure, or the minting session's end. A later mint by that session under the same label also ends an ordinary code, but not a device approval |
| A storage transfer grant | a browser, a file-transfer client, or the turnzero command | one named storage file: a download grant reads it and an upload grant writes it once. A deploy's upload grant also starts that deploy and reads its progress | a bearer on one named storage file route and, for a deploy's upload grant, on "deploy" for its upload's one start, then on the command's progress reads of that deploy |
until the returned expiry time, and a deploy's upload grant's progress reads until five minutes after its deploy ends, never past fifteen minutes after the start; refused while the owning account is suspended | the file being written using an upload grant, and for a deploy's upload grant its one start, then its progress window's end; expiry, application deletion, account erasure |
| An export download grant, a kind of transfer grant | the turnzero command, on your machine | reading one export's files and the stored files it listed; it writes and lists nothing | a bearer on GET of a named storage file: every file of one completed export, and the application's stored files in the export's environment that were created by the time the export listed them. It writes nothing and lists nothing |
until the returned expiry time, five minutes after minting by default, and a read does not use it up; refused while the owning account is suspended | expiry, application deletion, account erasure |
| A secret grant | the turnzero command, on your machine | one store_secret write of one name at one scope, with replace: true for a replacement. A provision line's grant re-mints the local run's platform credential, and its database credential if the manifest declares a database, each once |
a bearer on store_secret on the HTTP API, for one write of one name at one scope. For a provision line's grant, it is a bearer on store_secret with replace: true for the local run's platform credential and any declared database's credential. A provision line's grant has no value; its bearer is this computer's verifier |
until the returned expiry time, fifteen minutes; refused while the owning account is suspended | its one write, or each write the provision grant permits; expiry, application deletion, account erasure; for a provision grant, a later submission for its application naming the same challenge |
| A one-time link | you, in a browser | the one task it opens: accepting an invitation, or adding a sign-in method to your account | a URL your AI tool prints | an invitation 14 days by default; a link ticket ten minutes | its one use, expiry, invite_end_user with the invitation's id in invitation |
A sign-in that would open an end user's 101st live session, in a browser or a native app, ends the oldest.
What each credential may do #
A request's permissions depend on the credential, its scope, and its grants. What happens without asking says which actions complete in the call and which wait for a person's approval.
- Your AI tool's connection, signed in through the browser, may call every action open to your account. A connection opened by device sign-in has fewer permissions. In a browser, your session calls the actions the signed-in pages use. Only a person in a browser approves a destructive action.
- A minted token has the scope it was minted with, the whole account or one application, and only the grants its minting session both had and asked for (Minted tokens).
- The platform credential acts for one environment of its application (The platform credential).
- An end-user session identifies a user of your application. It authorizes no management action.
When an ending takes effect #
Revocation, rotation, and suspension affect credentials at different times on different endpoints. Suspension permanently ends sign-in sessions; separately minted tokens are refused during suspension and can work again after reinstatement.
| Endpoint | When an ending takes effect | During a control-plane outage |
|---|---|---|
| The HTTP API, the MCP endpoint, and the accounts service | At once. | — |
| The storage, logging, and egress endpoints | Within 30 seconds, because each keeps a checked credential for 30 seconds before checking it again. An egress key's check is kept the same way. | Each keeps accepting a credential it has already checked, for up to an hour from its last successful check, then refuses it. The HTTPS tunnel's proxy keeps its last result for the same hour. |
| The serving router | When the router's cached result expires and it checks the control plane again. | It keeps serving the application as it last read it, so your application stays up. |
A suspension or reinstatement made during an outage reaches the serving router when the control plane responds again. Platform staff can set a limit on that instead. Past the limit, every request on the application's hostname but the three well-known documents is refused with HTTP 503 and standing_stale until the control plane responds again.
After a rename with rename_application, a person signed in through a browser signs in again on the new hostname, in development as in production. The browser keeps the sign-in cookie for the previous hostname only (Rename the application).
Signing in #
Sign in with Google, GitHub, an emailed six-digit code, or a registered passkey. For emailed codes, enter the code in the browser that requested it within ten minutes. The email goes only to the entered address and contains no link. The emailed code gives the limits on attempts and codes.
A first sign-in creates an account while sign-ups are open. An invitation can still create an account when public sign-ups are paused. Connect your AI assistant covers your first sign-in.
A sign-in creates browser cookies. When an MCP client started the sign-in, the sign-in also authorizes that client's connection. The two are separate sessions from then on: the site's Sign out ends that browser's cookies alone, and the connection keeps renewing until you end it or sign out everywhere. A sign-in started from the site's header authorizes no AI tool.
Browser cookies #
A sign-in sets five cookies on the platform origin, each HttpOnly, Secure, and SameSite=Lax:
- The site cookie, for the whole origin, opens the site's gated pages, the documentation trees the account can read among them, and the passkey management page.
- The dashboard cookie, for
/dashboard, opens the signed-in site. - The API cookie, for
https://turnzero.ai/api/v1/actions/, lets a signed-in page of the site call the actions the signed-in pages use (Bearer tokens on the HTTP API). - The support cookie, for
/api/v1/support/, lets you allow the support agent to read your account for one chat and end that permission. - The approval cookie, for
/approve, lasts 8 hours from the sign-in. After that, an approval link asks you to sign in again.
The site, dashboard, API, and support cookies are one session, and every page you open renews all four. They expire together 30 days after your last visit, and none lasts more than 90 days from the sign-in that created it.
A dashboard change needs a sign-in within the last 8 hours. This includes changing an application's size, storing or deleting a secret, pausing or resuming an environment, uploading a file, running a schedule, and deleting an application.
Revoking a token, signing out everywhere and deleting the account bind to that window too. Adding or removing a passkey on the sign-in page does as well. Past the window, the action is refused fresh_authentication_required; follow Sign in again to return to the page after signing in. Observe reads continue for the cookie's life.
The tool's connection #
For a browser sign-in, your MCP client registers at /oauth/register and opens /oauth/authorize in your browser. The client handles the OAuth exchange; you complete sign-in and any consent page.
Anyone can register a client, so a registration has limits. It names at most ten redirect addresses, the addresses the sign-in returns to. Each is an https address, or an http address on your own computer (localhost, 127.0.0.1, or [::1]) at any port. None may hold a wildcard. Redirects to the platform's own domains or hosts under them are blocked, except for explicitly allowed tzMesh hosts and hosted application domains.
Some AI tools sign in from the web, such as the Claude apps and ChatGPT, so the sign-in returns to an address that is not on your computer. The sign-in page then names that address's host. After you sign in, a page asks whether to allow the tool. It names the tool by that host's name, with no port, then the account you signed in to and what the tool will have access to, such as your applications. Choose Allow access only if you just connected a tool at that host. Cancel tells the tool you said no.
If you signed in within the last 8 hours, that page opens at once, with no sign-in first. An AI tool on your own computer, such as Claude Code or Codex, gets no such page after a sign-in. Within those 8 hours a page asks whether the tool may use your Turn Zero account instead. It names the tool by the name it registered, or as an app on this computer, and says what the tool will have access to. Choose Allow access, or Cancel to say no.
The client then exchanges the returned code at /oauth/token for an access token that lasts 30 days and a refresh token that lasts 60 days. It presents the access token as a bearer on every request to the MCP endpoint. When the access token expires, the client renews the pair with the refresh token, which the renewal uses up, without another interactive sign-in.
The platform rejects an access token as soon as you sign out everywhere, revoke the connection, or the account is suspended or erased. Renewal keeps the connection bound to the same MCP endpoint, client, and original sign-in. Each of the three MCP addresses is a separate protected resource: sign in through the client to each address you use. A token issued for one address does not sign in to another.
The server responds to every request from a connection that has not signed in, its first request included, with the authentication challenge that starts the sign-in. On the HTTP API, the library's read_library and the published contracts' read_context need a sign-in or a token of your account.
Device sign-in limits #
An MCP client on a computer without a browser can sign in to https://turnzero.ai/mcp with a code that you approve in a browser on another computer. Sign in from a script describes that route.
The resulting connection can use tzTrack. It can also read account information and documentation, submit feedback, and check pending approvals. It cannot manage or deploy Cloud applications, mint tokens, export or delete your account, or use Turn Zero's storage or outbound-request services. A device_sign_in_bounded refusal means this sign-in cannot make that call. Use a normal browser sign-in, or a token minted from one, for Cloud management.
The limits remain when the client renews its tokens. Signing in as a platform staff member does not remove them. Any destructive action the connection can request still waits for your approval in a browser.
What ends a connection #
Five things normally end a connection:
- Sign out everywhere ends every session of the account at once: every browser's cookies and every connection, on every device, the one that asked included. It is on the Account & security page, and an AI tool calls it as
sign_out_everywhere. It also ends every product token a sign-in minted, and a passkey offer still open from a sign-in.sign_out_everywhereends every session of the account and keeps your existing passkeys. A renewal made at the same moment does not keep the connection signed in. Sign out in the dashboard menu ends that browser's cookies alone and no connection. revoke_tokenwithconnection, Disconnect on the Connected AI tools page, or the tool's own revocation ends that one connection at once. Every other connection and the browser's cookies stay valid.- Suspension of the account ends its sessions, refuses renewal, and ends an open passkey offer. Erasure ends everything. Reverting a passkey change (Identities and passkeys) ends every session the same way, and in the same step signs in again the browser that made the revert.
- A replayed refresh token. A used refresh token presented again within ten minutes gets a new pair from the same chain. An AI tool such as Claude Code keeps one stored credential for every process on your machine, and two of them can renew minutes apart. A used refresh token presented later than ten minutes revokes the whole chain to protect against a stolen token, and every holder signs in again.
- Sixty days without renewal, because the refresh token lasts 60 days.
A tool whose logout revokes its sign-in ends that one connection at once when it sends the refresh token or an access token that has not expired. Removing only its stored copy leaves the connection live on Turn Zero. Neither signs the account out everywhere. A routine upgrade of Turn Zero Cloud ends no connection: the connection, its refresh token, and your browser session are records in the platform's database.
If a client loses its stored credential or a renewal is refused, the client may ask you to reconnect. Sign in again through the host rather than editing tokens by hand.
Bearer tokens on the HTTP API #
Each management action's reference page gives its HTTP address. Account actions use https://turnzero.ai/api/v1/<action_name>. Cloud actions use https://tzcloud.turnzero.ai/v1/<action_name>, and tzTrack actions the plane provides use https://tztrack.turnzero.ai/v1/<action_name>.
These are production addresses. Where a local or development platform sets no separate host for a surface, use its origin with /api/tzcloud/v1/<action_name> for Cloud or /api/tztrack/v1/<action_name> for tzTrack. Where a separate host is set, that origin path is refused under another host.
Every action accepts POST, and an observe action, one that only reads, also accepts GET. The request body is the action's own payload, the same schema your AI tool reads in the published contracts (context://service_contracts), and refusals have the same names.
The credential is a bearer in the Authorization header: the connection's access token, or a minted token. The turnzero command also presents a token code on mint_token under login and token claim, and under authorize --mint the verifier it keeps on your computer, with no code. It presents a deploy's upload grant on that deploy's one start (The turnzero command). For its one write on store_secret, it can also be the secret grant in the line that such a call returns. A replacement uses store_secret with replace: true.
This computer's token is an account-scoped minted token. For an action supported by the turnzero command, have your script on that computer run the command, which handles the credential, instead of reading credentials.json itself. For a script that calls the HTTP API directly or runs elsewhere, mint a token for the script and use it from the script's secret store.
The signed-in site's API cookie instead uses https://turnzero.ai/api/v1/actions/<action_name>. A same-origin JSON post from a page of the site, with no Authorization header, is checked against that cookie on the actions the signed-in pages use. A state-changing action under it needs a sign-in within the last 8 hours. No other cookie is accepted there. A request with an Authorization header is checked against that header alone, never the cookie.
A bearer call at the site's cookie address is refused 410 action_address_moved; address gives the action's address. revoke_token is exempt, so an older command can still sign out.
The storage endpoints accept the same bearer, which is how a script uploads a deploy artifact. The same bearer also reads the documentation's machine files, as the “Machine surfaces of this documentation” section in the Cloud overview's Markdown copy describes. A connection opened by device sign-in cannot use these storage endpoints.
Minted tokens #
A minted token authenticates unattended work. Its scope is set when it is created: the whole account or one application. Mint a token gives the mint_token arguments and how to use the token.
- Expiry.
expires_in_days, an integer from 1 to 3650, makes the token expire after that many days. Without it, the token does not expire. A product's grant, and thetest_end_usersgrant, take at most 180 days, and 180 when you leave the days out. - Grants. A token receives only the grants its minting session both has and asks for. The destructive grant lets it request a destructive action, which a person still approves in the browser.
- Scope. A token bounded to one application cannot halt production:
halt_environmentonproductionunder it is refused 403account_credential_required.
mint_token returns a line, never the value. A token claim line mints the token once by its token code, on the computer that runs it. The line that authorizes your computer, turnzero authorize --mint <id>, carries no code: the command presents the verifier it kept on that computer (The challenge and the line). A token cannot mint another token. list_tokens returns token records without values, with when each was last used, so you can see a token nothing uses any more. A product token is the exception: its uses at its own service are not counted (the next section).
A token scoped to one application is refused the feedback actions with token_scope_refused, which a session or an account-scoped token may call (Feedback). The application's backend reaches its own space through the egress gateway instead.
A token minted with the issues grant reaches one issue space of your account and nothing else. It can call relay_issue_act for that space, list_tokens, and the public reads, and every other action refuses it with issues_bounded (A token for one issue space).
Every account has Turn Zero Track (tzTrack), so there is nothing to add. If minting a token with the issues grant, or a relay_issue_act call, is refused 403 blueprint_required, repeat the request. read_account lists the products your account has.
A token minted with the test_end_users grant creates, reads, and signs in your application's test end users on every realm, and keeps the rest of its scope's reach. Mint it through a signed-in session of your account and give it a label. No other unrevoked token with this grant in the same scope may use that label (A token for test end users).
Platform-staff grants are unavailable to customer sessions.
revoke_token ends a token. Later requests with it are refused at once on the HTTP API and the MCP endpoint, and on the storage, logging, and egress endpoints within the interval When an ending takes effect gives. Each action performed with a token records that token's identity.
Keep tokens in a secret store or another protected credential store. Avoid pasting them into chat. If a token is accidentally disclosed, written to a log or commit, or otherwise exposed beyond its intended use, revoke it and mint another.
Product tokens #
Some of Turn Zero's own products sign you in with a product token. When your MCP client connects to such a product's own MCP endpoint, the sign-in runs here, on this platform. The token it ends with is a minted token for that product: a signed value, which the product's service checks against a key set this platform publishes, with no call back here. Every product's token takes the same form, and each product has its own key set, revocation list, and prefix. The token lasts 180 days and is not renewed, so you sign in again when it expires.
For a product's own server, a script with no MCP client gets a product token through /oauth/device_authorization. It prints a code and a link for you to approve in a browser. Its next poll of /oauth/token gets the product token. Using the same sign-in route for https://turnzero.ai/mcp returns a limited session with a refresh token instead. Sign in from a script explains both paths.
A script can mint the same kind of token with mint_token and a product's grant, for at most 180 days (Mint a token). On this platform a product token reaches list_tokens, the public reads, and the few other actions its product's grant names, and nothing else. The product's service is where it acts.
Since the product's service checks the token with no call back here, list_tokens counts only the token's requests to this platform. Its row carries last_used_note saying so, and the Connected AI tools page shows its last use as "not tracked here" where none reached this platform. So an empty last use there is no sign that the connection is idle.
revoke_token, erasure, and the removal of the product from your account end it. A token the sign-in minted also ends at Sign out everywhere, a passkey change's revert, a later sign-in by the same client under the same label, and a suspension, as the next paragraph says. Each product's service reads this platform's revocation list for it once a minute, so an ending reaches the service within about a minute. Platform staff can also revoke a product's whole signing key set against a suspected disclosure. That ends every token of the product at once, and everyone signs in again.
A suspension of your account reaches every product's service through the same list. The suspension writes a suspended row to each product's revocation list, and the service refuses everything of yours it holds until a reinstated row follows. A product token the sign-in minted is ended by the suspension and is not restored. A product token minted with mint_token is refused while the suspension stands and works again after the reinstatement.
The platform credential #
A deployed backend calls the platform with a credential the platform creates for the application's environment and supplies as TURNZERO_CLOUD_APP_TOKEN. The backend uses it on the storage endpoints, the logging service, the egress gateway, and the accounts service's verification route. It is the one credential an email or push send accepts, and of the management actions it may call read_account alone. The credential is bound to its environment, so every call under it reaches that environment's storage, secret scope, log stream, and realm without naming it.
On an application with one environment, which has no development realm, the verification route checks the development credential's sessions against production's realm. It checks a session someone already has, and starts none.
There is one current credential per environment, and every application has a development one for its local runs. A deploy to development supplies the current value without creating a new one. How each environment's value is created:
- Development. The first manifest submission creates it. On the HTTP API the result returns it once, and through the MCP tool the submission withholds it. A submission naming
local_runandcode_challenge, the call thatturnzero provision --application <application id>prints, returns the provision line instead and withholds the value on either route. The line creates a new value usingstore_secretwithreplace: trueon the development scope and writes it into a local run's environment file. A new line replaces a lost value. - Production. Every deploy to production, on one environment, and every promote create a new value and supply it to the new container. The platform switches to that container only after its health check passes, so a failed deploy or promote leaves the current value in place.
Neither the deploy result nor the promote result returns the credential's value, and no production credential is ever shown to you.
The environment header #
A session or a minted token is bound to no environment. So a call under one names the environment in the header x-turnzero-cloud-environment, development or production, on the storage, logging, and egress endpoints and the verification route. A call without it is refused 400 environment_required. Under the platform credential, a header that names the other environment is refused 403 environment_mismatch. Each route's page gives its own variations, such as the logging batch's environment member and the verification route's body member.
End-user sessions #
Your application's users do not need Turn Zero accounts. They belong to the application's own realm, one for each environment the application has, and Manage end users covers each realm's sign-in methods and settings. A signed-in user has a session cookie on the application's own hostname. It lasts the realm's session length: 30 days by default, or the 1 to 30 days that configure_app_sign_in's session_days sets. Use the Account package to identify the user sending a request. set_end_user_standing with standing: suspended ends that user's sessions.
Native sessions #
A mobile app keeps the session as a bearer, not a cookie: the same signed token, beside a refresh credential. The app refreshes at the realm's token endpoint, and each refresh returns a fresh token and a fresh credential and extends the session by the realm's session length, up to session_cap_days from the sign-in. The router never renews a bearer, and refuses one it cannot verify with 401 authentication_required (Verifying an end user).
A refresh credential is single-use. Presenting a replaced one within sixty seconds returns a fresh pair, because a lost response is not theft. Presenting it later ends the session, and the app signs in again. Sign in from a native app covers the declaration, the exchange, and the refresh.
The one-time links your tool prints #
Some tasks finish in your browser, at a URL your AI tool prints or the turnzero command opens or prints:
- An approval link,
/approve/<id>, for a pending action. The page shows the platform's description of the change, and your click approves or declines it under the approval cookie. - The platform's sign-in page for the CLI,
/approve/computer. Once you approve, the platform mints a token code. Ordinaryloginopens it, then receives a callback or a code to paste. An AI tool can instead runlogin --deviceand send you its link. Open it on any device and approve only the sign-in you asked for on the named computer. The command finishes there without a pasted code (Sign in without a terminal). - A link ticket,
/link/<ticket>, fromlink_identity, valid for ten minutes. It opens the steps that add a second sign-in method to your account. - An invitation URL from
invite_end_userwithemail, for one address and one use, valid 14 days by default (Invitation URLs). - The passkey offer after a sign-in by emailed code, open for ten minutes and bound to that sign-in. Signing out everywhere ends it early: the offer is refused as
invalid_grant, and you add the passkey from the passkey page after a new sign-in. Signing that browser out clears the offer's cookie, so its routes refuseoffer_cookie_required, and the passkey is offered again at your next sign-in by code. A suspension ends it asaccount_suspended.
Invitation URLs #
An invitation to an application's realm is a URL on the hostname of the environment the issuing invite_end_user call names, which you deliver yourself (Invite people). After a rename, an invitation URL issued earlier stops working, because it holds the previous hostname, though the invitation can still be redeemed (Rename the application).
An invitation to the platform itself is a URL of the form /auth/invitation/<token> on the platform origin, which only platform staff issue. The platform emails it to the invited address, and the result's emailed says whether it was sent. Its page shows the invited address and the time the invitation expires, to the minute in UTC, and offers the sign-in methods; a link that cannot be used says only that.
Related #
- What happens without asking explains which actions a credential completes in the call and how a destructive action is approved.
- Verifying an end user explains how an application's backend checks an end-user session.
- Connect your AI assistant describes the first sign-in from an MCP client.
- Mint a token mints a token for a script or a pipeline.
- Sign in from a script explains signing in from a computer with no browser, either to the Turn Zero connection or to a product's own server.
- Your account covers the signed-in site, the account, and its standing.
- Identities and passkeys covers linked sign-ins and passkeys.
- Manage end users covers an application's realm, its sign-in methods, and its invitations.
- Actions lists every management action a customer can call, with its payload.