How to fix ERR WRONGTYPE Operation against a key holding the wrong kind of value in Redis

Use the TYPE command to inspect what data type is actually stored:

TYPE mykey

This returns the data type (string, list, set, hash, zset, stream, none, etc.). Run this in the Redis CLI or through your client library. This tells you what the key actually contains.

Match your command to the actual data type:

For strings: GET, SET, INCR, DECR, APPEND
For lists: LPUSH, RPUSH, LPOP, RPOP, LRANGE, LLEN
For sets: SADD, SREM, SMEMBERS, SISMEMBER, SUNION
For hashes: HSET, HGET, HGETALL, HDEL, HEXISTS
For sorted sets: ZADD, ZRANGE, ZREM, ZSCORE, ZCARD

If your code uses the wrong command category, update it to match the key's actual type.

If you own the data and do not need the old value:

DEL mykey

Then create the key with the correct type:

LPUSH mykey value  # for a list
# or
SADD mykey value   # for a set
# or
HSET mykey field value  # for a hash

This is the simplest solution if the old data is no longer needed.

If the old data is important for debugging or migration:

RENAME mykey mykey_old

Now create the key with the correct type using the original name:

LPUSH mykey value

This preserves the old data in mykey_old for inspection or rollback.

Sometimes WRONGTYPE appears because you are querying the wrong Redis instance or database index:

SELECT 0  # switch to database 0
TYPE mykey

Ensure your client library is connecting to the right Redis instance (correct host, port, and database index). Verify the key exists in the database you expect.

Review the code that triggered the error:

1. Verify all keys are used consistently throughout your codebase with the same data type
2. Add comments documenting the expected type for each key (e.g., // users:1 -> hash)
3. Use separate key prefixes or namespaces for different data types to avoid reuse (e.g., user:1:name for strings, user:1:tags for sets)
4. In client libraries, use type-safe abstractions or helper functions that enforce the correct operation for a key
5. Add unit tests that validate the data type before performing operations

This ensures future developers do not accidentally mix types on the same key.