# What Is the TTL for User Profile Cache in Nitter?

> Discover the TTL for user profile cache in Nitter. Learn how Nitter caches profiles for one hour (3600 seconds) using the baseCacheTime constant.

- Repository: [Zed/nitter](https://github.com/zedeus/nitter)
- Tags: internals
- Published: 2026-08-29

---

**Nitter caches user profiles for exactly one hour (3,600 seconds), defined by the `baseCacheTime` constant in the Redis caching layer.**

Nitter is an alternative Twitter front-end that relies on aggressive caching to reduce API load and improve response times. Understanding the **TTL for user profile cache in Nitter** helps developers and self-hosters predict data freshness and debug stale profile issues. The implementation uses Redis as the backend store with hardcoded expiration logic that applies uniformly to all cached user objects.

## Where the TTL Is Defined

The expiration duration lives in `src/redis_cache.nim` as the global constant **`baseCacheTime`**.

```nim

# src/redis_cache.nim (lines 9-10)

const
  baseCacheTime = 60 * 60  # 3600 seconds = 1 hour

```

This constant represents the baseline freshness window for all volatile cache entries. The value is calculated as `60 * 60` to produce **3,600 seconds**, ensuring profiles never persist longer than one hour regardless of traffic patterns.

## How the TTL Is Applied

When Nitter fetches a user from Twitter’s API, it serializes the `User` object and writes it to Redis using the **`cache(User)`** procedure. This function constructs a key prefixed with `p:` (e.g., `p:example_user`) and applies the TTL via the `setEx` command.

In `src/redis_cache.nim` (lines 92-97), the implementation resembles:

```nim
proc cache*(user: User) {.async.} =
  let key = "p:" & user.username
  await redis.setEx(key, baseCacheTime, user.serialize())

```

The **`setEx`** atomic operation stores the serialized user data and sets the expiration atomically. If a subsequent request arrives after 3,600 seconds have elapsed, Redis automatically deletes the key, forcing Nitter to re-fetch fresh data from the upstream API.

## Working with the Cache Programmatically

Self-hosters extending Nitter can interact with this caching layer directly. The following Nim examples demonstrate manual cache inspection and refresh patterns:

**Writing a profile with the standard TTL:**

```nim
import redis_cache, types
let user = await getGraphUser("example_user")
await cache(user)  # Automatically expires after baseCacheTime (3600s)

```

**Checking for a valid cached entry:**

```nim
let cached = await get("p:" & "example_user")
if cached != redisNil:
  let user = cached.deserialize(User)
  # user is guaranteed to be less than 1 hour old

else:
  # Cache miss or TTL expired; fetch fresh data

  let fresh = await getGraphUser("example_user")
  await cache(fresh)

```

Because the TTL is immutable at runtime, you cannot extend the lifetime of a specific entry without modifying the source and recompiling.

## Related Source Files

The caching system spans several modules:

- **`src/redis_cache.nim`** – Contains `baseCacheTime`, the `cache(User)` procedure, and Redis connection management.
- **`src/types.nim`** – Defines the `User` object structure that gets serialized and stored.
- **`src/api.nim`** and **`src/apiutils.nim`** – Provide `getGraphUser()` and related functions that populate the cache when misses occur.

## Summary

- Nitter stores user profiles in Redis using the key pattern `p:<username>`.
- The **TTL is hardcoded to 3,600 seconds (1 hour)** via the `baseCacheTime` constant.
- The **`cache(User)`** procedure in `src/redis_cache.nim` applies this TTL using `setEx`.
- After expiration, Redis evicts the key automatically, triggering a fresh fetch from Twitter’s API on the next request.
- There is no runtime configuration to adjust this duration; changing the TTL requires modifying the source code.

## Frequently Asked Questions

### How long does Nitter cache a user profile?

Nitter caches each user profile for **one hour**. The exact duration is defined by `baseCacheTime = 60 * 60` seconds in `src/redis_cache.nim`, and it applies uniformly to every profile stored in Redis.

### Can I change the user profile cache duration?

No, not without recompiling. The TTL is a compile-time constant (`baseCacheTime`) rather than a configuration parameter. To alter the duration, you must edit `src/redis_cache.nim`, change the value, and rebuild the Nitter binary.

### What happens when a cached profile expires?

When the 3,600-second TTL elapses, Redis automatically deletes the `p:<username>` key. The next request for that user triggers a cache miss, causing Nitter to invoke `getGraphUser()` (or similar) to retrieve fresh data from Twitter’s API and repopulate the cache with a new 1-hour expiration.

### Where does Nitter store cached user data?

Cached profiles reside in **Redis** under keys prefixed with `p:`. For example, the user `example_user` is stored at key `p:example_user`. This naming convention allows the `cache(User)` and retrieval logic to isolate profile data from other cached content like tweets or search results.