Authentication

Session Management Best Practices: Cookies, Tokens, and Rotation

Stateful sessions vs. stateless tokens, cookie security flags, refresh token rotation, idle and absolute timeouts, and how to revoke access when it matters.

Emilian GheoneaJune 10, 20267 min read

Logging a user in is the easy part. Keeping them logged in — securely, across requests, devices, and tabs, while still being able to kick them out instantly — is where most of the real design work lives. This article covers the decisions that make up good session management.

Stateful sessions vs. stateless tokens

There are two broad approaches to remembering that a user is authenticated.

Stateful (server-side) sessions. The server stores session data (in a database, Redis, etc.) and gives the client an opaque session ID, usually in a cookie. Every request looks the session up server-side.

  • Pros: trivial revocation (delete the row), no sensitive data on the client, easy to inspect.
  • Cons: requires a session store and a lookup on every request.

Stateless tokens (JWTs). The server issues a signed token containing the claims. No server-side lookup is needed — the signature proves validity.

  • Pros: scales horizontally with no shared session store, fast to verify.
  • Cons: revocation is hard. A valid token is valid until it expires, full stop.

In practice, the strongest designs combine both: short-lived stateless access tokens for fast per-request checks, plus a long-lived, revocable refresh token backed by server-side state. You get the performance of stateless verification and the control of server-side revocation.

Rendering diagram…

If your access tokens are JWTs, the trade-offs of signing algorithm, key rotation, and why revocation is hard are covered in depth in JWT Explained for Developers.

Cookie security flags

If you store session identifiers or tokens in cookies — and you usually should — set these flags:

  • HttpOnly — the cookie can't be read by JavaScript, which neutralizes token theft via XSS.
  • Secure — the cookie is only sent over HTTPS.
  • SameSite — controls cross-site sending. Lax is a sensible default; Strict is tighter but breaks some cross-site navigation flows; None (which requires Secure) is needed for legitimate cross-site contexts like embedded iframes.
  • Path and Domain — scope the cookie as narrowly as the application allows.
Set-Cookie: session=...; HttpOnly; Secure; SameSite=Lax; Path=/; Max-Age=900

Why HttpOnly cookies beat localStorage: tokens in localStorage are readable by any script on the page, so a single XSS bug exfiltrates them. An HttpOnly cookie is invisible to JavaScript, so the same bug can't steal it directly. (XSS itself, and how it turns into session theft, is one of the failure modes in Common Authentication Vulnerabilities.)

Setting the cookie correctly from a Node backend:

res.cookie('session', sessionId, {
  httpOnly: true,       // invisible to JavaScript — blocks XSS token theft
  secure: true,         // HTTPS only
  sameSite: 'lax',      // 'none' + secure only if the cookie must cross sites (e.g. iframes)
  path: '/',
  maxAge: 15 * 60 * 1000,
});

A note on embedded contexts: if your auth lives inside a cross-origin iframe, a first-party SameSite=Lax cookie on your own domain still works — it's the third-party cookie set inside the frame that browsers now block. This is precisely why embedded authentication is designed to return a token by message and let your own origin set its own first-party session.

Access tokens and refresh tokens

The two-token pattern works like this:

  • The access token is short-lived (often 5–15 minutes) and presented on each request. Because it expires quickly, a stolen access token has a small window of usefulness.
  • The refresh token is long-lived, stored securely (ideally an HttpOnly cookie), and used only to obtain new access tokens. It's tracked server-side so it can be revoked.

When the access token expires, the client silently exchanges the refresh token for a new access token. The user never notices.

Refresh token rotation

A long-lived refresh token is a juicy target, so harden it with rotation: every time a refresh token is used, issue a brand-new one and invalidate the old.

The payoff is theft detection. If an attacker steals a refresh token and uses it, the legitimate user's next refresh will present the now-invalidated old token. Detecting reuse of a rotated token is a strong signal of compromise — at which point you revoke the entire token family and force re-authentication.

1. Client refreshes with token A  -> server issues token B, invalidates A
2. Attacker later replays token A  -> server sees a used/invalid token
3. Server revokes the whole family -> both parties must log in again

The key implementation detail is the family ID: every refresh token descended from the same original login shares a family identifier. Rotation moves the "current" pointer forward within a family; reuse of any superseded member burns the entire family. Store enough state to answer two questions cheaply — "is this the current token in its family?" and "has this family been revoked?"

Rendering diagram…

Timeouts: idle vs. absolute

Two different limits, and you want both:

  • Idle timeout — the session ends after a period of inactivity (e.g. 30 minutes). Protects unattended sessions.
  • Absolute timeout — the session has a hard maximum lifetime regardless of activity (e.g. 7–30 days). Bounds how long a single login can last before re-authentication.

Sensitive operations (changing a password, payment details, deleting data) should additionally require step-up authentication — re-confirming identity even within a valid session.

Revocation: the feature you'll wish you had

At some point a user will report a lost laptop, or you'll detect a compromised account, and you'll need to end sessions right now. Build this in from the start:

  • Maintain a server-side record of active sessions/refresh tokens so each can be revoked individually.
  • Offer users a "sign out everywhere" action and a list of active sessions with device and location info.
  • On password change, invalidate all existing sessions by default.
  • Keep access tokens short-lived so that even pure-stateless revocation has a small ceiling on how long a revoked user stays authenticated.

The session record: what to actually store

"Keep server-side session records" is easy to agree with and easy to under-build. A session row that contains only a user ID and an expiry gives you revocation and nothing else. The extra fields cost almost nothing and unlock the features users and auditors ask for later.

  • Created-at and last-seen-at. Created-at drives the absolute timeout; last-seen-at drives the idle timeout. Keep them separate — collapsing them into one column means you can no longer distinguish "logged in three weeks ago, active all along" from "logged in three weeks ago, dormant."
  • IP and user agent at creation. Not for authorization — both are trivially spoofed, and binding a session to an IP breaks every user on a mobile network. They are for the user: "Chrome on macOS, Berlin, 2 hours ago" is what makes an active-sessions list actionable.
  • A device label. Derived from the user agent, stored at creation. Parsing the UA string at display time means old sessions render differently after you upgrade the parsing library.
  • The authentication method. Whether this session came from a password, a magic link, SSO, or a passkey. This is what lets you require step-up for sensitive actions when the session was established by a weaker method, and what lets you kill all password-derived sessions when a customer switches to enforced SSO.
  • The refresh token family ID. Links the session to the rotation chain so revoking one revokes the other.

Writing last_seen_at on every request is a write amplification problem — one database write per API call. The standard fix is to only update it when it is more than a minute or two stale, which keeps the idle timeout accurate to within the granularity you actually care about.

Idle timeouts are harder than they look

The naive implementation extends the session on every authenticated request, which sounds right and is wrong in a specific way: background activity counts as activity. A polling dashboard, a service worker syncing, a websocket heartbeat, an open tab refreshing a chart every thirty seconds — all of these keep the session alive indefinitely on an unattended machine, which is precisely the scenario the idle timeout exists to prevent.

If the idle timeout is a real security control for your product rather than a checkbox, distinguish user activity from request activity. A pragmatic split: background and automated requests are authorized normally but do not refresh the idle clock; requests carrying an explicit user-interaction signal do. The simplest version is to only extend on requests that mutate state or that the client explicitly marks as user-initiated.

The other half is telling the user before it happens. A session that silently expires mid-form-fill and discards their work is worse than one that logs them out five minutes earlier with a warning. A countdown modal at the two-minute mark, with a "stay signed in" button that makes a real request, costs very little and eliminates an entire category of complaint.

Cross-tab and cross-device consistency

Users expect signing out in one tab to sign them out everywhere, and refreshing a token in one tab shouldn't break another. The storage event and the BroadcastChannel API let tabs coordinate session state. For multi-device consistency, server-side session records are the source of truth.

A practical default

For most web applications, a solid baseline is:

  • Short-lived access token (5–15 min), long-lived rotating refresh token in an HttpOnly, Secure, SameSite cookie.
  • Server-side session/token records for revocation.
  • Idle timeout plus an absolute lifetime.
  • "Sign out everywhere," active-session listing, and full invalidation on password change.
  • Step-up auth for sensitive actions.

None of this is glamorous, but session management is where authentication quietly succeeds or fails. The systems users trust most are the ones that keep them logged in seamlessly — and can throw them out instantly the moment something's wrong.

Session management doesn't stand alone: the refresh tokens above are only as safe as the rate limiting on your refresh endpoint, and the whole scheme assumes you got the token format and verification right. EmbedAuth issues short-lived access tokens with rotating, revocable refresh tokens and lists every active session in the dashboard, so revoking one is a click rather than a project.

Written by

Emilian Gheonea

Senior Blockchain & Full-Stack Software Engineer. I build EmbedAuth — an embeddable authentication platform for SaaS — and write about the auth problems most teams hit too late.