Redis on a Free Tier: Redis Mini at $12 Versus Upstash's Free Plan, by the Numbers

Most small apps need Redis for one of four jobs: sessions, rate limiting, a cache, or a queue. On a free container tier you have two honest ways to get one. Upstash gives you a serverless Redis with a real free plan and per-command pricing. SnapDeploy gives you a dedicated Redis 7 instance next to your containers for $12 a month. They are not the same product, and the right one depends on how many commands you send and what kind. Here is the arithmetic and the cases.

The two offers

The arithmetic

Count commands, not requests. A typical web request that reads a session, checks a rate limit and touches a cache sends four to eight Redis commands. So:

1,000 requests/day x 6 commands x 30 days =   180,000 commands/month  -> inside Upstash's free 500,000
5,000 requests/day x 6 commands x 30 days =   900,000 commands/month  -> about $0.80/month on Upstash
$12 on Upstash pay-as-you-go buys about 6,000,000 commands a month
                                              -> above roughly 33,000 requests/day, Redis Mini is cheaper

For a hobby app with hundreds of visitors a day, Upstash is free and stays free. For an app doing tens of thousands of requests a day, the flat $12 wins. In between, both are cheap and the decision is about the kind of work, not the price.

Where Upstash fits better

• An app that is mostly idle. The free container sleeps after 15 minutes; an Upstash database is there when it wakes, at no cost in between. A dedicated Redis runs all month whether or not the app does.
• Edge and serverless callers. The REST interface works from Cloudflare Workers, Vercel functions and anywhere a TCP connection is awkward.
• Sessions, rate limits, small caches. Few commands per request, tiny values, nothing time-critical.

Where Redis Mini fits better

• Queues. Job libraries such as BullMQ, Sidekiq or Celery with a Redis broker use blocking reads and send many commands per job, which is exactly what per-command pricing punishes. On a dedicated instance a queue costs nothing extra per job. For a proper broker, RabbitMQ Mini ($14/month) is also there.
• Pub/sub and anything chatty. Real-time features, presence, counters updated on every event.
• Data larger than 256 MB, or a cache hit rate that matters: a dedicated instance in the same region answers in well under a millisecond over the private connection string; a global serverless endpoint answers in a few milliseconds.
• Persistence you control. Redis Mini keeps its data on persistent storage with daily backups, so a restart does not empty it.

Wiring either one

Both are a URL. Read it from the environment and let the client library handle reconnects, because on the free tier your container will sleep and wake and the first command after a wake reopens the connection:

// Node, ioredis
const Redis = require("ioredis");
const redis = new Redis(process.env.REDIS_URL, { maxRetriesPerRequest: 3, enableOfflineQueue: false });

# Python, redis-py
import os, redis
r = redis.from_url(os.environ["REDIS_URL"], socket_timeout=2, retry_on_timeout=True)

Upstash URLs use rediss:// (TLS) and both libraries handle that from the scheme. With a SnapDeploy Redis add-on the variable is injected into the container; with Upstash you paste it. Keep a short socket timeout: a cache that hangs for 30 seconds is worse than a cache miss.

Try before you pay

The $1 DB Sprint Pack provisions the same Redis Mini for 12 hours. That is enough to run a queue worker against it, watch memory in the dashboard, and know whether 512 MB holds your working set before committing to the month. Data is kept for 24 hours after the trial ends, and converting to the monthly plan keeps the same instance.

A note on "free Redis" in general

We do not offer a free Redis for the same reason we do not offer a free database: a dedicated instance runs around the clock whether or not your app does, and a cache that sleeps is a cache that is empty when you need it. Upstash solves that with a multi-tenant serverless engine, which is real engineering and a fair trade for per-command pricing. Use it when your numbers fit; use the dedicated instance when they do not.

Sizing: what fits in 512 MB, and in 256 MB

Redis keeps everything in memory, so the question is the size of your working set. A session is usually under a kilobyte; a cached rendered fragment a few kilobytes; a rate-limit counter a few bytes. Half a gigabyte holds hundreds of thousands of sessions or a large page cache with room to spare, and Upstash's 256 MB is enough for most hobby apps. What blows either up is caching whole API responses without an expiry: set a TTL on everything that can be recomputed, and check INFO memory (the used_memory_human line) once a week until you know the shape of your data.

Moving between the two later

Both speak the Redis protocol, so the application change is one environment variable. Data mostly does not need to move: a cache warms itself, rate-limit counters expire, and sessions expire or users sign in again. The one thing to drain first is a queue: stop enqueueing, let the workers empty it, switch the URL, start again. If you must copy keys, DUMP and RESTORE work across any two Redis endpoints, and redis-cli --rdb can pull a snapshot from a server that allows it.

Test locally first

docker run --rm -p 6379:6379 redis:7
REDIS_URL=redis://localhost:6379 npm start   # or python app.py

A local Redis 7 is the same engine as the Mini add-on. If the app works against it, the only differences in production are the URL and, on the free tier, the container waking up before the first command.