1. What is a Redis Bitmap?

A Redis Bitmap is a set of bit-oriented operations on Redis Strings (internally implemented using Simple Dynamic Strings, or SDS). Since strings are binary-safe and can contain up to 512 MB, you can work with bits (4,294,967,296 bits or ~536 million bytes).

2. Basic Operations: SETBIT and GETBIT

2.1.

SETBIT

2.1.1.

Syntax

It sets the bit at a given offset to 0 or 1:

Copy
1SETBIT key offset value

Parameters:

• key: The bitmap key name
• offset: Bit position (0-based index)
• value: 0 or 1

Returns: Previous bit value at that offset (0 or 1)

2.1.2.

Example

Set bit at position 0 to 1:

Copy
1SETBIT user:login:20260301 0 1

Set bit at position 5 to 1:

Copy
1SETBIT user:login:20260301 5 1

Setting bit at large offset automatically allocates memory

Copy
1SETBIT user:login:20260301 1000000 1

• Redis allocates enough bytes to hold bit at position 1,000,000

• Memory used: = 125,001 bytes

2.2.

GETBIT

2.2.1.

Syntax

It returns the bit value at a given offset:

Copy
1GETBIT key offset

2.2.2.

Example

Set some bits:

Copy
1SETBIT user:login:20260301 10 1
2SETBIT user:login:20260301 25 1

Read bits:

Copy
1GETBIT user:login:20260301 10

Returns: 1

Copy
1GETBIT user:login:20260301 25

Returns: 1

Unassigned bits default to 0:

Copy
1GETBIT user:login:20260301 50

Returns: 0

Reading beyond allocated memory returns 0:

Copy
1GETBIT user:login:20260301 999999999

Returns: 0

2.3.

DEL - Delete Bitmap Key

2.3.1.

Syntax

Removes the entire bitmap key from Redis:

Copy
1DEL key [key ...]

Parameters:

• key: One or more keys to delete

Returns: Number of keys deleted

2.3.2.

Example

Delete a single bitmap:

Copy
1DEL user:login:20260301

Returns: 1 (key deleted)

Delete multiple bitmaps at once:

Copy
1DEL user:login:20260301 user:login:20260302 user:login:20260303

Returns: 3 (three keys deleted)

After deletion, the key no longer exists:

Copy
1GETBIT user:login:20260301 100

Returns: 0 (key doesn't exist, all bits are 0)

Copy
1EXISTS user:login:20260301

Returns: 0 (key doesn't exist)

3. Use Cases

3.1.

User Login Status Tracking

3.1.1.

Bitmap Approach

Track which users logged in on a specific date. Each user ID maps to a bit offset.

Date: 1st March, 2026, users of userId: 100, 250, 1000, 5000 logged in:

Copy
1SETBIT user:login:20260301 100 1
2SETBIT user:login:20260301 250 1
3SETBIT user:login:20260301 1000 1
4SETBIT user:login:20260301 5000 1

Check if user 100 logged in:

Copy
1GETBIT user:login:20260301 100

Returns: 1 (yes)

Check if user 500 logged in:

Copy
1GETBIT user:login:20260301 500

Returns: 0 (no)

Check if user 5000 logged in:

Copy
1GETBIT user:login:20260301 5000

Returns: 1 (yes)

Python implementation:

Copy
1import redis
2from datetime import datetime
3
4r = redis.Redis(decode_responses=True)
5
6def mark_user_login(user_id: int, date: str):
7    """Mark user as logged in on specific date"""
8    key = f"user:login:{date}"
9    previous = r.setbit(key, user_id, 1)
10    print(f"User {user_id} login on {date} - Previous: {previous}")
11    return previous
12
13def check_user_login(user_id: int, date: str) -> bool:
14    """Check if user logged in on specific date"""
15    key = f"user:login:{date}"
16    status = r.getbit(key, user_id)
17    return bool(status)
18
19# Usage
20date = datetime.now().strftime('%Y%m%d')
21
22mark_user_login(100, date)
23mark_user_login(250, date)
24mark_user_login(1000, date)
25
26print(check_user_login(100, date))   # True
27print(check_user_login(500, date))   # False
28print(check_user_login(1000, date))  # True

3.1.2.

Memory Efficiency Comparison to Set Approach

Copy
1SADD user:login:20260301 100 250 1000 5000
2MEMORY USAGE user:login:20260301

Copy
1SETBIT user:login:bitmap:20260301 100 1
2SETBIT user:login:bitmap:20260301 250 1
3SETBIT user:login:bitmap:20260301 1000 1
4SETBIT user:login:bitmap:20260301 5000 1
5MEMORY USAGE user:login:bitmap:20260301

3.2.

User Statistics - Daily Active Users (DAU)

Track daily active users across multiple days and calculate statistics.

3.2.1.

Data Setup

Login data of 1-5th March, 2026:

Copy
1SETBIT dau:20260301 100 1
2SETBIT dau:20260301 200 1
3SETBIT dau:20260301 300 1
4
5SETBIT dau:20260302 100 1
6SETBIT dau:20260302 300 1
7SETBIT dau:20260302 400 1
8
9SETBIT dau:20260303 200 1
10SETBIT dau:20260303 300 1
11SETBIT dau:20260303 500 1
12
13SETBIT dau:20260304 100 1
14SETBIT dau:20260304 200 1
15SETBIT dau:20260304 300 1
16SETBIT dau:20260304 400 1
17
18SETBIT dau:20260305 100 1
19SETBIT dau:20260305 500 1

3.2.2.

Calculation via BITCOUNT and BITOP (Bitvalue Operation)

3.2.2.1.

Count total active users per day

Copy
1BITCOUNT dau:20260301

Returns: 3 (users 100, 200, 300)

Copy
1BITCOUNT dau:20260302

Returns: 3 (users 100, 300, 400)

Copy
1BITCOUNT dau:20260303

Returns: 3 (users 200, 300, 500)

3.2.2.2.

Find users active on both March 1 AND March 2

Copy
1BITOP AND dau:mar1_and_mar2 dau:20260301 dau:20260302
2BITCOUNT dau:mar1_and_mar2

Returns: 2 (users 100 and 300)

3.2.2.3.

Find users active on March 1 OR March 2

Copy
1BITOP OR dau:mar1_or_mar2 dau:20260301 dau:20260302
2BITCOUNT dau:mar1_or_mar2

Returns: 4 (users 100, 200, 300, 400)

3.2.2.4.

Find users active in March 1-5 (union)

Copy
1BITOP OR dau:march_week1 dau:20260301 dau:20260302 dau:20260303 dau:20260304 dau:20260305
2BITCOUNT dau:march_week1

Returns: 5 (users 100, 200, 300, 400, 500)

3.2.2.5.

Find users active ALL 5 days (intersection)

Copy
1BITOP AND dau:active_all_5days dau:20260301 dau:20260302 dau:20260303 dau:20260304 dau:20260305
2BITCOUNT dau:active_all_5days

Returns: 1 (only user 300 logged in all 5 days)

Python implementation for analytics:

Copy
1import redis
2from datetime import datetime, timedelta
3
4r = redis.Redis(decode_responses=True)
5
6def calculate_dau(date: str) -> int:
7    """Calculate Daily Active Users for a specific date"""
8    key = f"dau:{date}"
9    return r.bitcount(key)
10
11def calculate_wau(start_date: str, num_days: int = 7) -> int:
12    """Calculate Weekly Active Users"""
13    keys = []
14    start = datetime.strptime(start_date, '%Y%m%d')
15    
16    for i in range(num_days):
17        date = (start + timedelta(days=i)).strftime('%Y%m%d')
18        keys.append(f"dau:{date}")
19    
20    result_key = f"wau:{start_date}"
21    r.bitop('OR', result_key, *keys)
22    wau = r.bitcount(result_key)
23    r.expire(result_key, 3600)  # Expire temporary key in 1 hour
24    
25    return wau
26
27def calculate_retention(cohort_date: str, check_date: str) -> float:
28    """Calculate retention rate from cohort_date to check_date"""
29    cohort_key = f"dau:{cohort_date}"
30    check_key = f"dau:{check_date}"
31    result_key = f"retention:{cohort_date}_to_{check_date}"
32    
33    # Users active on both days
34    r.bitop('AND', result_key, cohort_key, check_key)
35    retained = r.bitcount(result_key)
36    
37    # Total users in cohort
38    cohort_size = r.bitcount(cohort_key)
39    
40    r.expire(result_key, 3600)
41    
42    if cohort_size == 0:
43        return 0.0
44    
45    return (retained / cohort_size) * 100
46
47# Usage
48print(f"DAU on 2026-03-01: {calculate_dau('20260301')}")
49print(f"WAU starting 2026-03-01: {calculate_wau('20260301', 7)}")
50print(f"Retention from 2026-03-01 to 2026-03-05: {calculate_retention('20260301', '20260305'):.2f}%")
Show All (50 lines)

4. BITPOS - Find First Set Bit

Returns the position of the first bit set to 0 or 1.

4.1.

Syntax

Copy
1BITPOS key bit [start [end [BYTE|BIT]]]

Parameters:

• key: Bitmap key
• bit: 0 or 1 (which bit value to find)
• start: Optional start offset
• end: Optional end offset
• BYTE|BIT: Unit for start/end (default: BYTE)

Returns: Position of first bit, or -1 if not found

4.2.

Examples

4.2.1.

Find first occurence

Create bitmap:

Copy
1SETBIT mybitmap 0 0
2SETBIT mybitmap 1 0
3SETBIT mybitmap 2 1
4SETBIT mybitmap 10 1
5SETBIT mybitmap 100 1

Find first bit set to 1:

Copy
1BITPOS mybitmap 1

Returns: 2 (first 1 is at position 2)

Find first bit set to 0:

Copy
1BITPOS mybitmap 0

Returns: 0 (first 0 is at position 0)

Create another bitmap:

Copy
1SETBIT users 0 1
2SETBIT users 1 1
3SETBIT users 2 1
4SETBIT users 5 0

Find first 0 bit:

Copy
1BITPOS users 0

Returns: 3 (positions 0,1,2 are 1, position 3 is 0)

Find first 1 starting from byte 0:

Copy
1BITPOS users 1 0

Returns: 0

4.2.2.

Range search

Set bits at various positions:

Copy
1SETBIT range:test 0 1
2SETBIT range:test 8 1
3SETBIT range:test 16 1
4SETBIT range:test 24 1

Find first 1 in byte , where (bits 0-7):

Copy
1BITPOS range:test 1 0 0 BYTE

Returns: 0 (first 1 in byte 0)

Find first 1 in byte , where (bits 8-15):

Copy
1BITPOS range:test 1 1 1 BYTE

Returns: 8 (first 1 in byte 1)

Find first 1 in byte , where (bits 16-31):

Copy
1BITPOS range:test 1 2 3 BYTE

Returns: 16 (first 1 in byte 2, 3)

4.2.3.

Find first available slot

Copy
1import redis
2
3r = redis.Redis(decode_responses=True)
4
5def find_next_available_slot(key: str) -> int:
6    """Find next available slot (first 0 bit) in a bitmap"""
7    position = r.bitpos(key, 0)
8    if position == -1:
9        # All bits are 1, return next position
10        length = r.strlen(key)
11        return length * 8
12    return position
13
14def reserve_slot(key: str) -> int:
15    """Reserve next available slot and return its position"""
16    slot = find_next_available_slot(key)
17    r.setbit(key, slot, 1)
18    print(f"Reserved slot {slot}")
19    return slot
20
21def release_slot(key: str, slot: int):
22    """Release a reserved slot"""
23    r.setbit(key, slot, 0)
24    print(f"Released slot {slot}")
25
26# Usage
27key = "parking:slots"
28
29# Reserve 3 slots
30slot1 = reserve_slot(key)  # Returns: 0
31slot2 = reserve_slot(key)  # Returns: 1
32slot3 = reserve_slot(key)  # Returns: 2
33
34# Release slot 1
35release_slot(key, slot1)
36
37# Reserve again
38slot4 = reserve_slot(key)  # Returns: 0 (reuses released slot)
Show All (38 lines)

5. BITFIELD - Advanced Bitmap Operations

BITFIELD allows you to treat a bitmap as an array of integers of arbitrary bit width. You can set, get, and increment integer values at specific bit offsets.

5.1.

Syntax

Copy
1BITFIELD key [GET type offset] [SET type offset value] \
2    [INCRBY type offset increment] [OVERFLOW WRAP|SAT|FAIL]

5.2.

Data Types: u\<N\> and i\<N\>

BITFIELD works with integer types encoded in N bits:

• u<N>: Unsigned integer with N bits

  • u1: 0 to 1 (1 bit)
  • u8: 0 to 255 (8 bits)
  • u16: 0 to 65535 (16 bits)
  • u32: 0 to 4,294,967,295 (32 bits)
  • Maximum: u63 (unsigned 63-bit)

• i<N>: Signed integer with N bits (two's complement)

  • i1: -1 to 0 (1 bit)
  • i8: -128 to 127 (8 bits)
  • i16: -32768 to 32767 (16 bits)
  • i32: -2,147,483,648 to 2,147,483,647 (32 bits)
  • Maximum: i64 (signed 64-bit)

N represents the number of bits used to encode the integer. For example:

• u8 uses 8 bits and can store values 0-255
• i8 uses 8 bits and can store values -128 to 127
• u3 uses 3 bits and can store values 0-7

5.3.

Subcommand: SET

Sets an integer value at a specific bit offset.

5.3.1.

Syntax

Copy
1BITFIELD key SET type offset value

Returns: Previous value at that offset

5.3.2.

Example

Copy
1# Set an unsigned 8-bit integer (value 100) at bit offset 0
2BITFIELD mykey SET u8 0 100
3# Returns: [0] (previous value)
4
5# Set unsigned 8-bit integer at bit offset 8 (next byte)
6BITFIELD mykey SET u8 8 200
7# Returns: [0]
8
9# Set unsigned 8-bit integer at bit offset 16
10BITFIELD mykey SET u8 16 255
11# Returns: [0]
12
13# Read current state
14BITFIELD mykey GET u8 0 GET u8 8 GET u8 16
15# Returns: [100, 200, 255]
16
17# Overwrite first value
18BITFIELD mykey SET u8 0 50
19# Returns: [100] (previous value was 100)

Using different bit widths:

Copy
1# Store small values efficiently with u4 (4 bits, range 0-15)
2BITFIELD compact SET u4 0 15
3# Returns: [0]
4
5BITFIELD compact SET u4 4 12
6# Returns: [0]
7
8BITFIELD compact SET u4 8 7
9# Returns: [0]
10
11# 3 values stored in 12 bits (1.5 bytes) instead of 12 bytes (3x 32-bit integers)
12
13# Read them back
14BITFIELD compact GET u4 0 GET u4 4 GET u4 8
15# Returns: [15, 12, 7]

5.4.

Subcommand: GET

Retrieves an integer value from a specific bit offset.

5.4.1.

Syntax

Copy
1BITFIELD key GET type offset

Returns: Value at that offset

5.4.2.

Example

Copy
1# Set some values first
2BITFIELD data SET u16 0 1000
3BITFIELD data SET u16 16 2000
4BITFIELD data SET u16 32 3000
5
6# Get individual values
7BITFIELD data GET u16 0
8# Returns: [1000]
9
10BITFIELD data GET u16 16
11# Returns: [2000]
12
13# Get multiple values in one command
14BITFIELD data GET u16 0 GET u16 16 GET u16 32
15# Returns: [1000, 2000, 3000]
16
17# Use signed integers
18BITFIELD signed SET i8 0 -50
19BITFIELD signed SET i8 8 100
20
21BITFIELD signed GET i8 0 GET i8 8
22# Returns: [-50, 100]

5.5.

Subcommand: INCRBY

Increments an integer value at a specific bit offset.

5.5.1.

Syntax

Copy
1BITFIELD key INCRBY type offset increment

Returns: New value after increment

5.5.2.

Example

Copy
1# Initialize counter at bit offset 0
2BITFIELD counter SET u8 0 10
3# Returns: [0]
4
5# Increment by 5
6BITFIELD counter INCRBY u8 0 5
7# Returns: [15] (10 + 5)
8
9# Increment by 10
10BITFIELD counter INCRBY u8 0 10
11# Returns: [25] (15 + 10)
12
13# Decrement (negative increment)
14BITFIELD counter INCRBY u8 0 -5
15# Returns: [20] (25 - 5)
16
17# Multiple operations in one command
18BITFIELD counter INCRBY u8 0 5 INCRBY u8 8 3 INCRBY u8 16 -2
19# Returns: [25, 3, -2]

Overflow behavior with unsigned integers:

Copy
1# Set u8 to maximum value (255)
2BITFIELD overflow_test SET u8 0 255
3# Returns: [0]
4
5# Increment by 1 (overflow!)
6BITFIELD overflow_test INCRBY u8 0 1
7# Returns: [0] (wraps around to 0 by default)
8
9# Set to 0 and decrement
10BITFIELD overflow_test SET u8 0 0
11BITFIELD overflow_test INCRBY u8 0 -1
12# Returns: [255] (wraps around to max value)

5.6.

OVERFLOW Handling: WRAP, SAT, FAIL

Controls what happens when an operation would cause overflow or underflow.

5.6.1.

Syntax

Copy
1BITFIELD key OVERFLOW WRAP|SAT|FAIL ...subsequent operations...

Modes:

• WRAP: Wrap around on overflow (default behavior)

  • Unsigned: 255 + 1 = 0, 0 - 1 = 255
  • Signed: 127 + 1 = -128, -128 - 1 = 127

• SAT: Saturate at min/max value

  • Unsigned: 255 + 1 = 255, 0 - 1 = 0
  • Signed: 127 + 1 = 127, -128 - 1 = -128

• FAIL: Return nil and don't modify value

  • Returns null when overflow would occur

5.6.2.

Examples

Copy
1# WRAP mode (default)
2BITFIELD wrap SET u8 0 255
3BITFIELD wrap OVERFLOW WRAP INCRBY u8 0 1
4# Returns: [0] (wraps to 0)
5
6BITFIELD wrap SET u8 0 0
7BITFIELD wrap OVERFLOW WRAP INCRBY u8 0 -1
8# Returns: [255] (wraps to max)
9
10# SAT mode (saturate)
11BITFIELD sat SET u8 0 255
12BITFIELD sat OVERFLOW SAT INCRBY u8 0 10
13# Returns: [255] (saturates at max, doesn't overflow)
14
15BITFIELD sat SET u8 0 0
16BITFIELD sat OVERFLOW SAT INCRBY u8 0 -10
17# Returns: [0] (saturates at min, doesn't underflow)
18
19# FAIL mode
20BITFIELD fail SET u8 0 255
21BITFIELD fail OVERFLOW FAIL INCRBY u8 0 1
22# Returns: [nil] (operation fails, value unchanged)
23
24BITFIELD fail GET u8 0
25# Returns: [255] (value not modified)

Signed integer overflow:

Copy
1# WRAP with signed integers
2BITFIELD signed SET i8 0 127
3BITFIELD signed OVERFLOW WRAP INCRBY i8 0 1
4# Returns: [-128] (wraps to minimum signed value)
5
6BITFIELD signed SET i8 0 -128
7BITFIELD signed OVERFLOW WRAP INCRBY i8 0 -1
8# Returns: [127] (wraps to maximum signed value)
9
10# SAT with signed integers
11BITFIELD signed SET i8 0 127
12BITFIELD signed OVERFLOW SAT INCRBY i8 0 10
13# Returns: [127] (saturates at max)
14
15BITFIELD signed SET i8 0 -128
16BITFIELD signed OVERFLOW SAT INCRBY i8 0 -10
17# Returns: [-128] (saturates at min)

Multiple operations with different overflow modes:

Copy
1BITFIELD multi SET u8 0 100 SET u8 8 200
2
3# Apply different overflow modes to different operations
4BITFIELD multi \
5  OVERFLOW WRAP INCRBY u8 0 200 \
6  OVERFLOW SAT INCRBY u8 8 100
7# Returns: [44, 255]
8# (100 + 200 = 300, wraps to 44)
9# (200 + 100 = 300, saturates at 255)

5.7.

Interesting Use Case: 31-Day User Activity Statistics

Track whether a user was active each day of the month using a single 31-bit bitmap per user. Each bit represents one day.

5.7.1.

Data Setup

Copy
1# User 1000: Active on days 1, 3, 5, 7, 9, 11, 13, 15
2SETBIT activity:march:1000 0 1
3SETBIT activity:march:1000 2 1
4SETBIT activity:march:1000 4 1
5SETBIT activity:march:1000 6 1
6SETBIT activity:march:1000 8 1
7SETBIT activity:march:1000 10 1
8SETBIT activity:march:1000 12 1
9SETBIT activity:march:1000 14 1

5.7.2.

Check activity (total amount in a month)

Copy
1BITCOUNT activity:march:1000
2# Returns: 8 (active 8 days)

5.7.3.

Check daily activity using BITFIELD for efficient storage and retrieval

Activities in a month are condensed into 31 bits allocated to the key

• activity:march:1000

we retrieve it by:

Copy
1BITFIELD activity:march:1000 GET u31 0

which results in 1431633920, a simple javascript (or counterpart in any language) yields

Copy
1const dua = 1431633920;
2const binaryString = dua.toString(2);
3// '1010101010101010000000000000000'

6. Summary

Redis Bitmaps provide memory-efficient boolean tracking through bit-level operations:

Core commands:

• SETBIT: Set individual bits
• GETBIT: Read individual bits
• BITCOUNT: Count set bits
• BITPOS: Find first 0 or 1 bit
• BITOP: Perform AND, OR, XOR, NOT operations
• BITFIELD: Work with multi-bit integers

Key advantages:

• Extreme memory efficiency (1 bit per boolean)
• Fast bitwise operations
• Track millions of users with minimal memory
• Atomic operations for concurrent access

Common patterns:

• User activity tracking (daily, weekly, monthly)
• Feature flags and permissions
• Real-time analytics (DAU, MAU, retention)
• Resource allocation (parking slots, seats)
• A/B testing cohorts

BITFIELD use cases:

• Compact integer arrays
• Activity counters with overflow protection
• Multi-day statistics in single key
• Space-efficient time series data