Redis
DatabaseIn-memory data store and cache
Sub-millisecond in-memory data store with rich data structures that solve caching, queuing, real-time analytics, and pub/sub with single commands — the universal infrastructure layer behind fast applications.
Redis is an ultra-fast in-memory data store used as a cache, message broker, and database. Its sub-millisecond response times make it essential for real-time applications, session management, and rate limiting.
Reviewed by the AI Tools Hub editorial team · Last updated February 2026
Redis — In-Depth Review
Redis (Remote Dictionary Server) is the world's most popular in-memory data store, used by virtually every major tech company for caching, session management, real-time analytics, and message brokering. Created by Salvatore Sanfilippo in 2009, Redis processes millions of operations per second with sub-millisecond latency — performance that disk-based databases simply cannot match. It's the invisible infrastructure behind fast-loading pages, real-time leaderboards, rate limiters, and chat systems across the internet.
Beyond Simple Key-Value: Data Structures
What separates Redis from other key-value stores is its rich set of data structures. Beyond basic strings, Redis natively supports hashes, lists, sets, sorted sets, bitmaps, HyperLogLogs, streams, and geospatial indexes. A sorted set can power a real-time leaderboard with O(log N) inserts and range queries. A stream can serve as a lightweight message broker. HyperLogLogs count unique elements with 0.81% error using just 12KB of memory. These aren't add-ons — they're built into the core, each with optimized commands that make common patterns trivial to implement.
Redis Stack and Modules
Redis Stack extends the core with modules for JSON documents (RedisJSON), full-text search (RediSearch), time series data (RedisTimeSeries), probabilistic data structures (RedisBloom), and graph queries (RedisGraph, now deprecated). RediSearch is particularly powerful — it adds secondary indexing, full-text search with stemming and phonetic matching, and vector similarity search for AI/ML applications. These modules turn Redis from a pure cache into a multi-model database capable of handling diverse workloads in memory.
Persistence and Durability
Despite being in-memory, Redis offers two persistence mechanisms: RDB snapshots (point-in-time dumps at configurable intervals) and AOF (Append Only File, which logs every write operation). You can use both together for maximum durability. AOF with "everysec" fsync provides a good balance — you lose at most one second of data on crash. For use cases like caching where data loss is acceptable, you can disable persistence entirely for maximum performance. Redis Cluster provides replication across nodes, so data survives individual server failures.
Redis Cloud and Hosting Options
Redis Ltd. (the company, rebranded from Redis Labs) offers Redis Cloud, a fully managed service on AWS, Google Cloud, and Azure. The free tier provides 30MB — enough for development and small caches. Paid plans start at ~$5/month for 250MB. Alternatives include AWS ElastiCache, Azure Cache for Redis, Google Cloud Memorystore, and self-hosting. For most applications, managed Redis with 1-5GB of memory ($50-200/month) handles millions of daily requests comfortably.
Common Patterns
The most common Redis use cases follow well-established patterns. Caching: store database query results with TTL (time-to-live) to reduce load on your primary database. Session storage: keep user sessions in Redis for fast lookups across stateless application servers. Rate limiting: use INCR with EXPIRE to implement sliding window rate limiters. Pub/Sub: real-time message broadcasting for chat and notification systems. Job queues: use lists with BRPOP for reliable background job processing (libraries like Bull, Sidekiq, and Celery use Redis as their broker). Distributed locks: use SET with NX and EX for coordinating access across microservices.
Where Redis Falls Short
Redis stores everything in RAM, which is expensive. Storing 100GB in Redis costs 10-50x more than the same data in PostgreSQL on disk. This makes Redis unsuitable as a primary database for large datasets — it's a complement, not a replacement. Redis Cluster adds operational complexity with hash slots, resharding, and client-side routing. The single-threaded event loop (multi-threaded I/O was added in Redis 6) means CPU-intensive Lua scripts or large key operations can block all other clients. And the 2024 license change from BSD to dual RSALv2/SSPL has created uncertainty, spurring forks like Valkey (backed by the Linux Foundation).
Pros & Cons
Pros
- ✓ Sub-millisecond latency with millions of operations per second — the fastest data store available for caching and real-time workloads
- ✓ Rich data structures (sorted sets, streams, HyperLogLogs, geospatial) solve common problems with single commands instead of application code
- ✓ Extensive ecosystem with mature client libraries for every language and battle-tested job queue frameworks (Sidekiq, Bull, Celery)
- ✓ Redis Stack modules add full-text search, JSON support, and vector similarity search without a separate system
- ✓ Simple API with intuitive commands — GET, SET, INCR, ZADD — that developers learn in minutes
Cons
- ✗ Memory-bound storage makes it expensive for large datasets — 100GB of Redis costs 10-50x more than the same in PostgreSQL
- ✗ Not a primary database replacement for most workloads — best used alongside a disk-based database, not instead of one
- ✗ License changed from BSD to dual RSALv2/SSPL in 2024, creating uncertainty and spawning the Valkey fork
- ✗ Single-threaded command processing means CPU-heavy Lua scripts or large key scans can block all other clients
- ✗ Redis Cluster adds operational complexity with hash slots, resharding, and multi-key command limitations across slots
Key Features
Use Cases
Application Caching Layer
The most common Redis use case: cache database queries, API responses, and computed results with TTL expiration. A Redis cache in front of PostgreSQL or MongoDB typically reduces p95 latency by 10-100x and cuts database load by 60-90%.
Session Storage for Web Applications
Stateless application servers store user sessions in Redis, enabling horizontal scaling without sticky sessions. Redis's sub-millisecond lookups make session retrieval invisible to users, and TTL handles automatic session expiration.
Real-Time Leaderboards and Counters
Sorted sets power real-time leaderboards with O(log N) inserts and instant ranking queries. Gaming companies, social platforms, and analytics dashboards use Redis sorted sets to maintain millions of ranked entries updated in real time.
Background Job Queues and Message Brokering
Libraries like Sidekiq (Ruby), Bull/BullMQ (Node.js), and Celery (Python) use Redis as a reliable job queue backend. Redis Streams provide a Kafka-like log-based messaging system for event-driven microservice architectures at smaller scale.
Integrations
Pricing
Free (OSS) / Cloud plans
Redis offers a free plan. Paid plans unlock additional features and higher limits.
Best For
Frequently Asked Questions
Should I use Redis as my primary database?
Generally no. While Redis supports persistence, its data size is limited by available RAM, which is expensive. Use Redis as a caching/session/queue layer alongside a primary database like PostgreSQL or MongoDB. The exception is if your dataset fits in memory (under ~50GB) and you need extreme performance — some applications use Redis as a primary store for real-time data like metrics, leaderboards, or rate limiting state.
What's the difference between Redis and Memcached?
Memcached is a simpler key-value cache that's slightly faster for basic string caching. Redis supports rich data structures (sorted sets, lists, streams, hashes), persistence, replication, Lua scripting, and pub/sub. For pure string caching, both work. For anything more complex — leaderboards, job queues, rate limiting, real-time analytics — Redis wins. Most teams choose Redis because it covers Memcached's use cases plus many more.
What happened with the Redis license change?
In March 2024, Redis Ltd. changed the license from the permissive BSD license to dual RSALv2/SSPL, which restricts cloud providers from offering Redis as a managed service without contributing back. This doesn't affect application developers using Redis, but it prompted the Linux Foundation to sponsor Valkey, a BSD-licensed fork. AWS, Google, and others now contribute to Valkey. For most users, both Redis and Valkey work identically.
How much memory does Redis need?
Redis uses roughly 2-10x more memory than the raw data size due to internal data structure overhead. A million simple key-value pairs of ~100 bytes each uses about 150-200MB. For production, plan for 2-3x your expected data size to account for overhead and growth. A 1GB Redis instance comfortably handles 5-10 million cached objects for most applications.
Can Redis replace Kafka for message queuing?
For small to medium scale (thousands of messages per second), Redis Streams provide Kafka-like functionality with consumer groups and message acknowledgment. For high-throughput event streaming (millions of messages per second), multi-day retention, or complex stream processing, Kafka is purpose-built and more appropriate. Redis Pub/Sub is fire-and-forget (no persistence), while Redis Streams offer durable messaging with replay capability.
Redis in Our Blog
Redis Alternatives
Redis Comparisons
Ready to try Redis?
Visit Redis →