# Sign-in and sessions

## Summary

A person signs in with their email address and password. Signing in starts a
session: the browser stays signed in for 30 days, until the person signs out,
or until the session is ended from somewhere else.

Each browser that signs in gets its own session. A person can see all of their
sessions, end one, or end all but the current one.

Sign-in attempts are limited. Too many attempts in 15 minutes are refused for
the rest of that time, with no lasting lockout.

This page also covers signing out (and what happens to unsaved drafts), where
the app goes after sign-in, and the account information a signed-in browser
can read.

## Who can do what

Organization roles (owner, admin, member) play no part here. A verified and an
unverified account behave the same on this page.

| Action | Signed-out visitor | Signed-in person | API key or connected app |
| --- | --- | --- | --- |
| Sign in | Yes | The app sends a signed-in browser on to the app instead of showing the form | Not a use for a credential. The operation is public and ignores a bearer token |
| Ask whether the browser is signed in | Yes | Yes | Public operation |
| Read the own account and its workspaces | No: `UNAUTHENTICATED` | Yes | No: `FORBIDDEN`, reason `SESSION_REQUIRED` |
| List the own sessions | No | Yes | No: `SESSION_REQUIRED` |
| End one of the own sessions | No | Yes | No: `SESSION_REQUIRED` |
| End all other sessions | No | Yes | No: `SESSION_REQUIRED` |
| Sign out | Nothing to end; answers success | Yes | No: `SESSION_REQUIRED` |

Nobody can see or end another person's sessions. No role grants that.

No operation on this page is an MCP tool. No credential scope grants any of
them. A credential does not sign in: it is sent with each request
([Credentials and scopes](../agents/credentials.md)).

## How it works

### Signing in

- Sign-in takes an email address and a password. They are the only way to sign
  in to the app.
- Spaces at both ends of the email are removed. The address is matched without
  regard to upper and lower case.
- The password must match exactly. It is never trimmed.
- A wrong password and an unknown email get the same answer:
  `401 INVALID_CREDENTIALS`, "Email or password is incorrect". The answer never
  says which one was wrong, or whether the address has an account.
- An account whose email is not verified signs in like any other. What it
  cannot do yet is listed in
  [Sign-up and email verification](sign-up.md#what-an-unverified-account-can-and-cannot-do).
- A deleted account cannot sign in. Its old address and password get
  `INVALID_CREDENTIALS`.
- Each successful sign-in starts a new session.
- One browser holds one session. If the browser that signs in already carries
  a live session, that session ends in the same step, whichever account it
  belonged to. Sessions in other browsers and on other devices are not ended.
- A refused sign-in ends nothing. The browser keeps the session it had.
- Closed sign-up does not affect sign-in. People with an account always sign
  in.
- There is no social sign-in: no signing in with an account of another
  service.
- There is no single sign-on.
- There is no two-factor authentication. The password alone signs in.
- There is no magic link, no one-time code and no passkey.
- There is no username. The email address identifies the account.
- There is no "Remember me". Every sign-in keeps the browser signed in for
  the full 30 days.
- No email is sent on a successful sign-in, from a new browser or a known
  one.

### Sessions

- A session belongs to one browser on one device. Tabs and windows of the same
  browser share it.
- A session lasts 30 days from the moment it started. Using the app does not
  extend it. After 30 days the person signs in again.
- A session starts in three ways: signing in, creating an account, or opening
  the verification link in the browser that created the account
  ([Sign-up and email verification](sign-up.md#verifying-the-email-address)).
- The browser keeps the session for the full 30 days. Closing the browser does
  not sign out.
- Each session records when it started, when it was last active, and the
  browser's `User-Agent` at the moment it started.
- "Last active" is updated at most once a minute.
- The recorded `User-Agent` has control characters removed and is cut to 512
  characters. A client that sends none has none recorded.
- A session ends early when:

| Event | Sessions that end |
| --- | --- |
| Signing out | The current one |
| A new session starts in a browser that already carries one: signing in, creating an account, or the verification link signing the browser in | The one that browser carried, also when it belonged to another account |
| "Revoke" on a session | That one |
| "Sign out other sessions" | All but the current one |
| Changing the password | All but the current one |
| Resetting the password from an emailed link | All, including the one in the browser that does the reset |
| Choosing a password from a verification link in another browser | All |
| Deleting the account | All |

- These do not end sessions: changing the email address, changing the name,
  verifying the email in a signed-in browser, joining or leaving an
  organization, and being removed from one.
- A browser whose session ended finds out at its next request. The app then
  opens the sign-in page and remembers the page the person was on or was
  moving to. See
  [Where the app goes after sign-in](#where-the-app-goes-after-sign-in).
- API keys and connected apps are not sessions. Signing out, revoking a
  session and "Sign out other sessions" leave them working. A password change
  or reset revokes them
  ([Password and email address](password-and-email.md)).

### What expires when

| Thing | Lifetime |
| --- | --- |
| A session | 30 days from its start |
| A verification link | 24 hours, or until it is used or replaced |
| A password reset link | 1 hour, or until it is used or replaced |
| An email change confirmation link | 24 hours, or until it is used, replaced or cancelled |
| An invitation link | 7 days, or until it is used, replaced or revoked |
| The browser's standing as the one that created an account | 30 days |
| A count of attempts | 15 minutes from the first attempt |

- A new password also ends links early: see
  [Password and email address](password-and-email.md#what-each-change-does).

### Limits on sign-in attempts

- Three counts apply, each over 15 minutes:

| Count | Limit | What counts |
| --- | --- | --- |
| One email address from one client address | 10 attempts | Every attempt, right or wrong |
| One client address | 100 attempts | Every attempt for any email, right or wrong |
| One email address from all client addresses together | 100 failed attempts | Wrong passwords only |

- The first 10 attempts for an email from one client address are checked. The
  11th is refused with `429 RATE_LIMITED` before the password is looked at, so
  even the correct password is refused until the 15 minutes end.
- A successful sign-in clears the count for that email from that client
  address. The count for the client address as a whole is not cleared.
- One address's wrong guesses never block the owner on another address. The
  owner's correct password signs in from a different network while the first
  address is limited.
- The third count stops guessing from many addresses at once. After 100 failed
  attempts for one email in 15 minutes, every sign-in for that email is
  refused, the correct password included, until the 15 minutes end. Correct
  passwords never add to this count.
- An unknown email is limited after the same number of attempts and with the
  same answers as a known one.
- A 15-minute window starts at the first attempt. Attempts refused during it do
  not make it longer.
- The refusal carries the wait: the `Retry-After` header and
  `details.retryAfterSeconds`, in whole seconds.
- There is no lasting lockout. No account is ever locked or disabled by failed
  attempts, and no email is sent about them.
- Resetting the password clears two counts: the failed attempts for the
  email from all client addresses together, and the attempts for the email
  from the client address that completed the reset. The person can sign in
  with the new password at once from that address. The count for the email
  from any other client address stays until its 15 minutes end.
- A request refused because the email or password is malformed is not counted.

### The sessions list

- A signed-in person sees every live session of their account: the device,
  when it was last active and when it signed in.
- Ended and expired sessions are not listed.
- The API lists sessions newest first. The app puts the current one first.
- Ending one session signs that browser out at its next request. No other
  session is touched.
- "Sign out other sessions" ends every session except the current one.
- The API can also end the current session by its ID. That clears the session
  cookie, like signing out. The app does not offer "Revoke" on the current
  session; "Sign out" does that.
- A session ID that is unknown, already ended, expired, malformed or another
  person's answers `404 NOT_FOUND`. Nothing is ended.

### Signing out

- Signing out ends the current session and clears it from the browser. Other
  sessions stay.
- Signing out without a session is not an error. It answers success.
- The app then opens the sign-in page. Going back in the browser does not show
  the signed-out account's pages: entering the app asks the server again.
- Signing out removes what the app kept for the account: the open tabs and
  unsaved drafts of the browser tab that signed out, and the browser's memory
  of the last used workspace and of an invitation link that was waiting.
- **Unsaved drafts.** If the current browser tab holds unsaved changes, "Sign
  out" does not sign out. It asks first, because signing out discards them.
  "Cancel" keeps the session, the page and the drafts. "Discard and sign out"
  signs out.
- Without unsaved drafts, "Sign out" signs out at once.
- The question is the same from the account menu and from the command palette.

### Where the app goes after sign-in

- A signed-out person who opens a page of the app lands on the sign-in page.
  After signing in, the app opens the page they asked for.
- The sign-in and sign-up pages carry this return path in the `returnTo` query
  parameter, as in `/sign-in?returnTo=/settings/security`.
- When a session ended while the app was open, the page is remembered
  however the app finds out: the page was opened or reloaded from its
  address, a page that was already open made the request, or the person
  moved inside the app to another page, such as "Credentials" in Settings
  or a file's page. In the last case the page they were moving to is the
  one remembered. Pointing at a link already loads its page; when that is
  what finds the session ended, the page they were still on is remembered.
- The return path is honored only when it is a path inside the app. An address
  on another site, or anything that does not start with `/`, is ignored and the
  app opens its start page.
- The sign-in page's notices come from the `notice` query parameter, which is
  `password-updated`, `email-verified` or `account-deleted`. Any other value
  is ignored.
- The return path is kept when moving between "Sign in" and "Create account".
  It is not kept through "Forgot password?": after a password reset, signing in
  opens the start page.
- A browser that is already signed in and opens the sign-in or sign-up page is
  sent straight to the return path, or to the start page.
- Without a return path, the app opens its start page:
  - an invitation that was opened before signing in opens first;
  - otherwise the last used workspace's Files & Assets;
  - an account with no organization gets "Set up your organization";
  - an account whose organizations gave it no workspace gets "No workspace
    yet".

### The account a session can read

- A signed-in browser reads its account: the ID, email address and full name,
  whether the email is verified, the new address of a pending email change,
  and every workspace the person can reach, each with its organization and the
  person's role in it.
- Workspaces are ordered by organization name, then workspace name.
- Workspaces of a deleted organization are not included.
- A second, public question answers "is this browser signed in?" without an
  error for a signed-out visitor: it returns the same account, or nothing.

## In the app

Words in braces, such as {address}, stand for the real value.

### The sign-in page

- Address: `/sign-in`.
- Heading: "Sign in". Fields: "Email" and "Password". Under the password:
  "Forgot password?". Button: "Sign in". Below: "New to Talewright? Create
  account".
- "Password" has a button at its end that shows what was typed, and hides
  it again. Every password field in the app has one.
- The form checks the fields before it sends anything: "Enter a valid email
  address." and "Enter your password."
- Refusals:
  - wrong email or password: "Email or password is incorrect."
  - too many attempts: "Too many sign-in attempts. Try again in 12 minutes."
    (the time varies; under 90 seconds it is given in seconds);
  - a malformed value the form did not catch: "Enter a valid email address and
    password.";
  - anything else: "Could not sign in. Try again."
- Changing a field clears the refusal.
- The page can open with a notice above the form:
  - "Password updated" - "Sign in with your new password." (after a password
    reset);
  - "Email verified" - "Sign in with your new password." (after choosing a
    password from a verification link);
  - "Account deleted" - "Your sessions have ended." (after deleting the
    account).
- The notice goes away when a sign-in attempt is refused.
- After a password reset in the same browser, "Email" starts filled with the
  address the reset was requested for.
- Coming from an invitation, "Email" starts filled with the invited address.

### Signing out

- Open the account menu at the bottom of the navigation. It shows the name and
  email address, "Settings", "Appearance" and "Sign out".
- Or open the command palette and choose "Sign out".
- "Set up your organization" also has a "Sign out" button.
- With unsaved drafts the dialog "Discard unsaved changes?" opens. It says "One
  draft has changes that are not saved. Signing out removes them from this
  browser." (or "3 drafts have changes that are not saved." with the count).
  Buttons: "Cancel" and "Discard and sign out".

### The sessions page

- Open Settings, then "Security", then "Sessions" (`/settings/security/sessions`).
- The section "Sessions" says "Browsers signed in to your account. Revoking a
  session signs that browser out."
- The table has the columns "Device", such as "Chrome on macOS" or "Safari
  on iOS", "Last active" and "Signed in", each with a date and time.
- The current session is first and is marked "This browser". It has no
  "Revoke" button.
- Every other row has "Revoke". After it: "Session revoked", and the row is
  gone.
- "Sign out other sessions" appears while there is at least one other session.
  After it: "Other sessions signed out".
- With more than 50 sessions, "Load more" shows the next ones.
- Failures: "Could not load your sessions.", "Could not revoke the session. Try
  again." and "Could not sign out other sessions. Try again."
- How a device is named:
  - a known browser (Edge, Firefox, Chrome, Safari) and a known system (iOS,
    iPadOS, Android, macOS, Windows, Linux): "Chrome on macOS";
  - only one of the two is known: that one alone;
  - neither: the client's own name, such as "curl/8.7.1";
  - no `User-Agent` at all: "Unknown device".

## For agents

These operations are for people in a browser. None is an MCP tool.

| Operation | Capability ID | Access | MCP |
| --- | --- | --- | --- |
| `POST /v1/auth/sign-in` | `auth.sign_in` | public | none |
| `GET /v1/auth/session` | `auth.session_probe` | public | none |
| `POST /v1/auth/sign-out` | `auth.sign_out` | session only | none |
| `GET /v1/me` | `auth.me` | session only | none |
| `GET /v1/me/sessions` | `account.sessions.list` | session only | none |
| `DELETE /v1/me/sessions/{sessionID}` | `account.sessions.revoke` | session only | none |
| `POST /v1/me/sessions/revoke-others` | `account.sessions.revoke_others` | session only | none |

- A session-only operation called with a valid API key is refused with
  `403 FORBIDDEN`, `details.reason` `SESSION_REQUIRED`, "This operation
  needs a person signed in with a browser".
- On a session-only operation, a bearer token that does not authenticate
  (a connected app's token included, which works only at MCP) is refused
  with `401 UNAUTHENTICATED`, reason `INVALID_TOKEN`.
- A public operation ignores a bearer token, valid or not.
- A request with both a session cookie and a bearer token is refused with
  `401 UNAUTHENTICATED`, reason `AMBIGUOUS_CREDENTIALS`.
- A request that changes something (`POST`, `PATCH`, `DELETE`) and carries a
  session cookie must send an `Origin` header equal to the app's origin. Such a
  request with any other `Origin` is refused with `403 FORBIDDEN`.

`POST /v1/auth/sign-in`

- Body: `email`, `password`.
- `204`: signed in. The response sets the cookie `__Host-session`, valid for 30
  days. No body. A live session named by the request's own `__Host-session`
  cookie is ended in the same step, whichever account it belonged to.
- `401 INVALID_CREDENTIALS`, `422 VALIDATION_FAILED` with `details.field`
  (`email` or `password`), `429 RATE_LIMITED` with `Retry-After`.

`GET /v1/auth/session`

- `200` with `{"me": null}` for a visitor without a live session, including an
  expired or invalid cookie. With a live session, `me` is the same object as
  `GET /v1/me`.

`GET /v1/me`

- `200` with `user` (`id`, `email`, `fullName`), `emailVerified`,
  `pendingEmail` (an address or `null`) and `workspaces` (each `id`, `name`,
  `organizationID`, `organizationName`, `role`).
- `401 UNAUTHENTICATED` without a live session.

`POST /v1/auth/sign-out`

- `204`, with or without a live session. The response clears the session
  cookie.

`GET /v1/me/sessions`

- Query: `cursor` and `limit` (1 to 100, default 50).
- `200` with `items` and `nextCursor`. Each item: `id`, `current`, `createdAt`,
  `lastSeenAt`, `userAgent` (a string or `null`). Newest first.

`DELETE /v1/me/sessions/{sessionID}`

- `204`: ended. If it was the current session, the response clears the cookie.
- `404 NOT_FOUND` for any ID that is not a live session of the caller.

`POST /v1/me/sessions/revoke-others`

- `204`, also when there was no other session.

Worked example: sign in, list the sessions, end the others, sign out.

```sh
curl -i https://app.usetalewright.com/v1/auth/sign-in \
  -c cookies.txt \
  -H 'Content-Type: application/json' \
  -d '{"email":"ada@example.com","password":"correct horse battery"}'
# 204 No Content
# set-cookie: __Host-session=...; Max-Age=2592000; Path=/; HttpOnly; SameSite=Lax; Secure

curl https://app.usetalewright.com/v1/me/sessions -b cookies.txt
# {"items":[
#   {"id":"0192...","current":true,"createdAt":"2026-11-14T09:12:03Z",
#    "lastSeenAt":"2026-11-14T09:12:03Z","userAgent":"curl/8.7.1"},
#   {"id":"0191...","current":false,"createdAt":"2026-11-02T17:40:11Z",
#    "lastSeenAt":"2026-11-13T08:01:55Z","userAgent":"Mozilla/5.0 ..."}],
#  "nextCursor":null}

curl -i -X POST https://app.usetalewright.com/v1/me/sessions/revoke-others \
  -b cookies.txt -H 'Origin: https://app.usetalewright.com'
# 204 No Content

curl -i -X POST https://app.usetalewright.com/v1/auth/sign-out \
  -b cookies.txt -c cookies.txt -H 'Origin: https://app.usetalewright.com'
# 204 No Content
```

A refused sign-in:

```json
{
  "error": {
    "code": "RATE_LIMITED",
    "message": "Too many attempts; try again later",
    "details": { "retryAfterSeconds": 742 }
  },
  "requestID": "01928f3e-7c1a-7d2b-9a41-3f0c2d9e8b17"
}
```

## Edge cases

Signing in

1. **The email is typed in another case than at sign-up.** It signs in. Why:
   addresses are matched without regard to case.
2. **The email has spaces around it.** They are removed.
3. **The password is typed with a trailing space that is not part of it.**
   Refused as a wrong password. Why: passwords are never trimmed.
4. **The email has no account.** The same answer as a wrong password, so
   nobody can tell the two apart.
5. **The account is unverified and the password is wrong.** "Email or password
   is incorrect.", with no hint that the account is unverified.
6. **The account is unverified and the password is right.** It signs in. The
   app shows the reminder "Verify your email".
7. **The account was deleted.** `INVALID_CREDENTIALS`, like an unknown email.
8. **The email address was changed and confirmed.** Only the new address signs
   in. The old one gets `INVALID_CREDENTIALS`.
9. **An email change was requested but not confirmed.** The old address still
   signs in. The new one does not.
10. **The password field is empty, or the email holds a control character.**
    `422 VALIDATION_FAILED` naming the field. The attempt is not counted.
11. **The request comes from a page on another site.** Refused with
    `403 FORBIDDEN`. Why: only the app itself may sign a browser in.

Limits

12. **Ten wrong passwords, then the right one, from the same address.** The
    right one is refused with `RATE_LIMITED` until the 15 minutes end.
13. **Nine wrong passwords, then the right one.** It signs in, and the count
    for that email from that address starts again at zero.
14. **The person is limited at home and tries from a phone on mobile data.**
    The correct password signs in. Why: the count is per client address.
15. **Many people sign in from one office address.** All of them share the
    limit of 100 attempts in 15 minutes for that address. Successful sign-ins
    count too.
16. **Someone guesses one account from many addresses.** After 100 failures in
    15 minutes nobody signs in to that account, the owner included, until the
    window ends. A password reset lifts it for the owner.
17. **The person is limited and resets the password.** The failed attempts for
    the email are cleared. The new password signs in at once from the address
    that completed the reset.
18. **A different account signs in from a limited address.** It works, as long
    as the address has not used up its own 100 attempts. Why: the 10-attempt
    count is per email.
19. **Attempts continue while limited.** Each is refused. The wait does not
    grow.

Sessions

20. **The person signs in on a second device.** Both sessions are live. Each is
    listed. The same holds for a second browser on one device.
21. **Two tabs of one browser.** They share one session. Signing out in one
    signs out the other, which opens the sign-in page the next time it loads
    data.
22. **A second account signs in in the same browser.** The browser now belongs
    to the second account. A tab still showing the first account drops
    everything it had loaded and shows the second account at its next load.
    The first account's session in that browser is ended in the same step. Its
    sessions in other browsers stay.
    - **The same account signs in again in a browser that is still signed
      in.** The app sends a signed-in browser past the sign-in page, so this
      takes a second tab opened before signing in, or the API. The new
      session replaces the old one: the old one stops working and leaves the
      sessions list.
    - **The sign-in is refused** (wrong password, unknown email, too many
      attempts). The session the browser carried keeps working.
23. **A session is 30 days old.** It stops working, even if it was used a
    minute ago. The app opens the sign-in page.
24. **A session is revoked while its browser has the app open.** That browser
    lands on the sign-in page at its next request. After signing in again it
    returns to the page it was on when that page made the request, or when
    the page was opened or reloaded from its address. When moving inside the
    app to another page is what finds the session ended, it returns to the
    page it was moving to.
25. **The password is changed in one browser.** That browser stays signed in.
    Every other browser is signed out.
26. **The password is reset from an emailed link.** Every browser is signed
    out, including the one that set the new password.
27. **The person is removed from an organization.** The session stays. The
    organization's workspaces disappear from the account.
28. **A session was started by a script that sent no `User-Agent`.** It is
    listed as "Unknown device".
29. **A browser the list does not know by name.** It is shown by what its
    `User-Agent` reports, so a browser built on another one can appear under
    that one's name.
30. **"Last active" looks a little old.** It is updated at most once a minute.
31. **An API key or a connected app is in use.** It does not appear among the
    sessions. Credentials have their own pages.

Ending sessions

32. **The same session is revoked twice.** The second answer is `404`.
33. **Someone tries another person's session ID.** `404`. Nothing is ended and
    nothing is revealed.
34. **The current session is revoked through the API.** It ends and the cookie
    is cleared.
35. **"Sign out other sessions" with no other session.** The app does not
    offer the button. The API answers success.
36. **Signing out when the session already ended.** Success. The cookie is
    cleared.

Signing out and drafts

37. **Sign out with an unsaved draft.** The dialog "Discard unsaved changes?"
    opens instead. Nothing is lost until "Discard and sign out".
38. **"Cancel" in that dialog.** The person stays signed in, on the same page,
    with the draft.
39. **Sign out from the command palette with a draft.** The same dialog.
40. **Back in the browser after signing out.** The sign-in page, not the
    account's pages.
41. **A shared computer.** After sign-out the browser tab that signed out
    holds no tabs or drafts of the account, and the browser no longer
    remembers its last used workspace or a waiting invitation link.

Return path

42. **A link to a page of the app is opened signed out.** Sign-in opens, and
    after it the linked page.
43. **The return path points at another site.** Ignored. The start page opens.
44. **A signed-in browser opens the sign-in page.** It goes on to the return
    path or the start page without showing the form.
45. **The person uses "Forgot password?" on the way.** The return path is lost.
    After the reset, signing in opens the start page.

## Errors

| Code | HTTP | Meaning here | What to do |
| --- | --- | --- | --- |
| `INVALID_CREDENTIALS` | 401 | "Email or password is incorrect". The email has no account or the password is wrong. | Check both. Use "Forgot password?" to set a new password. |
| `VALIDATION_FAILED` | 422 | A field is malformed. `details.field` is `email` ("email must be 1 to 320 characters" or "email must not contain control characters") or `password` ("password must be 1 to 1024 bytes"). | Correct the field. |
| `VALIDATION_FAILED` | 422 | On the sessions list: an invalid `cursor`, or a `limit` outside 1 to 100. | Use the `nextCursor` of the previous page and a valid limit. |
| `RATE_LIMITED` | 429 | "Too many attempts; try again later". `details.retryAfterSeconds` and `Retry-After` give the wait. | Wait, or reset the password. |
| `UNAUTHENTICATED` | 401 | "Authentication required". No live session: none was sent, or it expired or was ended. | Sign in again. |
| `UNAUTHENTICATED` | 401 | Reason `AMBIGUOUS_CREDENTIALS`: "Send either a session cookie or a bearer token, not both". | Send one. |
| `FORBIDDEN` | 403 | Reason `SESSION_REQUIRED`: "This operation needs a person signed in with a browser". A credential called a session-only operation. | Do it in the app. |
| `FORBIDDEN` | 403 | "Forbidden". The `Origin` header is not the app's origin, or a session cookie came without one. | Send requests from the app, or with the app's origin. |
| `NOT_FOUND` | 404 | "Not found". The session ID is not a live session of the caller. | Read the list again. |

## Limits

| What | Limit |
| --- | --- |
| Session lifetime | 30 days from its start; not extended by use |
| Sign-in attempts for one email from one client address | 10 in 15 minutes |
| Sign-in attempts from one client address | 100 in 15 minutes |
| Failed sign-ins for one email from all client addresses | 100 in 15 minutes |
| Email address at sign-in | 1 to 320 characters |
| Password at sign-in | 1 to 1024 bytes |
| "Last active" precision | Updated at most once a minute |
| Recorded `User-Agent` | At most 512 characters |
| Sessions per page in the list | 50 by default, 1 to 100 through the API |

## Questions and answers

**How long do I stay signed in?**
30 days from signing in, in that browser. Using the app does not extend it.

**Does closing the browser sign me out?**
No. The session lasts until it is 30 days old, you sign out, or it is ended
from somewhere else.

**I typed my password correctly and still got "Too many sign-in attempts".**
After 10 attempts for your address from one network in 15 minutes, every
further attempt is refused, the correct password included. Wait for the time
shown, try from another network, or reset your password.

**Is my account locked after too many wrong passwords?**
No. Limits last at most 15 minutes and nothing is disabled.

**Someone is trying to guess my password. What happens?**
Their guesses are limited per address and, across all addresses, to 100
failures in 15 minutes for your account. While that last limit is reached you
cannot sign in either. Resetting your password lets you in.

**Can I sign in before verifying my email?**
Yes.

**Why does the page not tell me whether the email or the password is wrong?**
So that nobody can use the sign-in page to find out who has an account.

**Can I be signed in on several devices?**
Yes. Each browser that signs in gets its own session. There is a list under
Settings, Security, Sessions.

**I signed in again in the same browser. Do I now have two sessions there?**
No. One browser holds one session. The new sign-in ends the session that
browser carried, also when it belonged to another account.

**I see a session I do not recognize.**
Choose "Revoke" on it, then change your password. Changing the password signs
out every other session and revokes your API keys and connected apps.

**How do I sign out everywhere?**
"Sign out other sessions" ends every session but the one you are using. Then
sign out. A password reset from an emailed link also ends every session.

**Why is there no "Revoke" on the session marked "This browser"?**
Ending the session you are using is what "Sign out" does.

**I revoked a session but that browser still shows the app.**
It is signed out at its next request. The page it already loaded stays on
screen until then.

**Does signing out revoke my API keys or connected apps?**
No. They keep working. Revoke them on their own pages, or change your
password, which revokes them all.

**What happens to changes I have not saved when I sign out?**
The app asks "Discard unsaved changes?" first. "Cancel" keeps them. "Discard
and sign out" removes them from the browser.

**After signing in I land on a different page than I expected.**
The app returns to the page you opened before signing in. Without one it opens
a waiting invitation, then your last used workspace.

**Can an agent sign in?**
An agent does not need to. It sends an API key or a connected app's token with
each request. The session operations on this page refuse such a token.

**Can an owner or admin see or end my sessions?**
No. Sessions are visible only to the person they belong to. Owners and admins
manage members' API keys and connected apps, not their sessions.

**Does changing my email address sign me out?**
No. Sessions stay. The next sign-in uses the new address.

**What does the sessions list call a device it does not know?**
The name the client reports, or "Unknown device" if it reported nothing.

## Related pages

- [Sign-up and email verification](sign-up.md)
- [Password and email address](password-and-email.md)
- [Deleting an account](delete-account.md)
- [Invitations](../organizations/invitations.md)
- [Credentials and scopes](../agents/credentials.md)
- [Errors](../reference/errors.md)
- [Limits](../reference/limits.md)

