How does key expiration (TTL) work in Redis?

Question

Accepted Answer

Redis lets keys **expire automatically** after a set time (**TTL** — Time To Live) — after which they're deleted. This is fundamental for caching (expiring stale data), sessions, and any temporary data, and is one of Redis's most-used features.

## Setting expiration

```bash
SET session:abc "data" EX 3600    # expire in 3600 seconds (1 hour)
SET key "value" PX 5000            # expire in 5000 milliseconds

# or set expiry on an existing key
SET cache:user:1 "..."
EXPIRE cache:user:1 300           # expire in 300 seconds
EXPIREAT key 1735689600           # expire at a specific Unix timestamp
```

You set a TTL when creating a key (`EX`/`PX`) or add one later (`EXPIRE`). After the TTL elapses, Redis automatically deletes the key.

## Checking and managing TTL

```bash
TTL session:abc        # => seconds remaining (e.g. 3540), -1 if no expiry, -2 if gone
PTTL session:abc       # remaining time in milliseconds
PERSIST session:abc    # remove the expiry → make the key permanent
```

`TTL` shows remaining time (`-1` = no expiry set, `-2` = key doesn't exist); `PERSIST` removes the expiry.

## How Redis expires keys

```text
Redis uses a combination of:
  LAZY expiration → when a key is accessed, if expired, it's deleted then
  ACTIVE expiration → a background process periodically samples and removes expired keys
→ So expired keys are cleaned up even if never accessed again (memory is reclaimed).
```

## Common uses of TTL

```text
✓ CACHING — cache data with a TTL so it auto-refreshes (stale data expires)
✓ SESSIONS — sessions expire after inactivity (set/refresh TTL on activity)
✓ RATE LIMITING — a counter with a TTL (e.g. "max 100 requests per minute")
✓ TEMPORARY data — OTPs, tokens, locks that should auto-clean
→ TTL means Redis manages cleanup automatically — no manual deletion needed.
```

## Why it matters

Key expiration (TTL) is one of Redis's most important and frequently-used features, so understanding it is essential for using Redis effectively, especially for caching.

The core capability — keys **automatically deleting after a set time** — is fundamental to Redis's most common use cases: **caching** (cache entries with a TTL so stale data automatically expires and refreshes — central to virtually every caching strategy), **sessions** (expiring after inactivity, refreshing the TTL on activity), **rate limiting** (a counter with a TTL implementing "N requests per time window"), and any **temporary data** (OTPs, tokens, locks) that should self-clean.

Understanding how to set TTLs (`EX`/`PX` on creation, `EXPIRE` afterward), check them (`TTL`, with its `-1`/`-2` return conventions), and manage them (`PERSIST`) is everyday practical knowledge.

Understanding **how Redis expires keys** (a combination of lazy expiration when accessed and active background sampling to reclaim memory even from never-accessed keys) explains how cleanup actually happens.

The key value is that TTL means **Redis manages cleanup automatically** — no manual deletion code needed, data self-expires — which is what makes Redis so convenient for caching and temporary data.

Since caching, sessions, rate limiting, and temporary data are among the most common Redis uses, and since TTL is the mechanism enabling automatic expiration central to all of them, understanding key expiration — setting/checking/managing TTLs, how expiration works, and its common uses — is essential, frequently-applied Redis knowledge, a feature you'll use constantly and one of the most practically important aspects of working with Redis.