Redis tools
Redis tools: key view and streams, IntelliSense, Cluster and Sentinel, profiler, Pub/Sub, memory analysis, bulk actions, ACL users, and value formats.
Redis gets its own set of tools beside the key browser. Two watch the server live on a dedicated connection, and the rest answer the admin questions Redis users ask most: where the memory went, how to clean up keys by the thousand, what a binary value actually holds, and whether the slow log is catching anything.
They work on Redis and the servers that speak its protocol - Valkey, KeyDB, DragonflyDB, Amazon ElastiCache, and Amazon MemoryDB, and on Redis Cluster (including ElastiCache cluster mode and MemoryDB), where commands are routed to the node that owns each key's slot, see Redis Cluster.
Connection diagnostics
Test Connection on a Redis connection walks the connection one step at a time and writes each step to the diagnostic log as it finishes, so you can see exactly how far it got. Open the log with ⌘⇧L (Ctrl+Shift+L); set Preferences › Advanced › Log level to Verbose to see every step, a failing step is logged at Errors only too. When a step fails, the error in the connection editor starts with that step - TLS failed: …, AUTH failed: … - instead of a generic "could not connect".
| Step | What it tells you |
|---|---|
| Database | New Query, Filter Keys…, Clear Key Filter, Scan more; a Bulk Edit submenu with Delete Keys by Pattern… and Set TTL by Pattern…; Import / Export with Import Command File… and Export as Command File…; Tools with Memory Analyzer…, Cluster Topology… (on a cluster), Profiler…, Pub/Sub…, Server Dashboard, Activity Monitor, Query Insights, Disk Usage, Query History, and Security (the ACL page); then Copy Name, Rename… and Show Only Databases… to name and pick the databases you see, and Refresh. |
| Key folder | Copy SCAN Command, Scan more, Delete Keys in Folder…, Set TTL in Folder…, Export Folder as Command File…. |
| Key | Open Value (the key view), Open in Query Tab; Rename…, an Expiry submenu with Set TTL… and Remove expiry (PERSIST), and Copy To with Copy to Database… and Copy to Connection…; Copy with Copy Name and Copy Command; Delete Key…. |
| Search index | Open (FT.INFO), Query…, Explain…, Profile…, Drop Index…. |
| Note row | Load more, Scan more. |
How SQLly's connections behave
- RESP3 when the server has it. SQLly asks for the RESP3 protocol and quietly stays on RESP2 when the server does not offer it. Results look the same either way.
SQLLY.SERVERINFOreports which one the connection uses. - Every connection has a name. Query tabs, the Profiler and the Pub/Sub viewer name their connections
sqlly:<connection name>:<process id>, soCLIENT LISTand the Activity Monitor's Sessions tab show which ones are SQLly's - including the Profiler's ownMONITORconnection. A server or ACL that refusesCLIENT SETNAMEjust leaves them unnamed. (On a server without RESP3, the Pub/Sub viewer's connection cannot be named.) - A command timeout. A command that gets no reply within the connection's Query timeout - 30 seconds when it is blank, no limit when it is 0 - fails with a message naming the command and the limit. Blocking commands get the wait you asked for on top, so
BLPOP jobs 20is never cut short. The command may still finish on the server, so SQLly never runs it again for you. The Profiler and Pub/Sub viewer wait without a limit. - SSH tunnels stay up. A tunnel sends an SSH keepalive every 30 seconds of silence (set Keepalive (seconds) in the tunnel settings; 0 turns it off), so idle tunnels survive firewalls and NAT timeouts. If the SSH session drops anyway, the next run opens a new tunnel and its Messages say Tunnel re-established. Nothing is re-run on your behalf, check whether the command that was running when the tunnel dropped took effect before you run it again.
The key browser
Redis has no catalog, so its part of the explorer is built from the keys themselves.
Expand a Redis server and you get its logical databases - db0,
db1, and so on, each with a key count. Expand a database and SQLly lists
its keys with one bounded SCAN walk (never KEYS *), folding
them into folders on the connection's key delimiters: user:42:profile lands
in user › 42. The delimiter is : unless you set others in
the connection editor's Key delimiters field. Type several characters to
split on each of them - :| folds both user:42 and
cache|en|home - or separate longer delimiters with spaces
(:: |); a single character, or one repeated like ::, keeps
meaning exactly that. Each key shows its type and, when it has one, its time to live.
A listing can be cut short in two ways, and one note row at the bottom covers both.
A walk stops at 10,000 keys, and the tree shows the first 2,000 rows of what it
scanned. The note says what is shown of what was scanned and whether the scan itself
stopped, for example Showing 2,000 of 7,350 rows from 10,000 scanned keys; the
SCAN stopped there. Click the note to load more rows (no rescan, they were already walked), or choose Scan more on the note, the
database or a folder to continue the same SCAN from where it stopped; the
new keys join the rows already shown and folder counts update. Use
Filter Keys… to narrow the listing to a pattern and
Clear Key Filter to go back. The filter is remembered per database on
the connection, so it is back in force the next time you open the app, and the Filter
Keys… dialog offers the last five patterns you typed on that connection in a
Recent dropdown. Folders re-scan their own prefix when you expand
them, so deep trees load a level at a time.
Filter Keys matches key names with a glob such as user:*; it never
looks inside values. If you type something that reads as a value query - JSON such as
{"name": "bob"} or a search query such as @name:bob - the dialog
says so instead of quietly listing nothing, and offers Search values with
FT.SEARCH…. On a server with the search module and an index, that opens a
query tab with an FT.SEARCH over the first index (the others are named in a
comment), turning JSON fields into @field:"value" clauses for you to review
and run; without an index or the module, the dialog explains what is needed. Cluster
hash tags like {user1}:* are ordinary patterns and never trigger the hint.
Key listings in a query tab
When you want to sort or filter keys rather than browse them, run
SQLLY.KEYS <pattern> <limit> in a query tab, for example
SQLLY.KEYS session:* 5000. It walks the keyspace with the same bounded
SCAN as the explorer and returns a normal grid with key,
type and ttl_seconds columns, so you can click the
ttl_seconds header to sort by time to live or use Filter
Rows… to keep, say, keys with no expiry or under an hour left.
Then act on what you found: select rows (or the whole key column),
right-click, and open Tools › Redis Keys for Delete Selected
Keys…, Set TTL on Selected Keys… or
Remove Expiry from Selected Keys…. The dialog lists the selected
keys first, a delete asks you to type the key count back, and nothing writes on a
read-only or locked production connection, the same gates as the
bulk actions. The same menu appears on
the Memory Analyzer's top-keys report shape (SQLLY.TOPKEYS) and on
SQLLY.KEYINFO; results whose key column is not a key name, such
as INFO, never offer it. The keys act on the connection and database the
tab runs against.
Each database row shows its key count and, when any key has an expiry, how many - 120 keys · expires: 7 - straight from the server's keyspace statistics. Opening a list, sorted set or stream reads its first 1,000 elements, and the tab is named that way (orders — first 1,000) so a long value is never mistaken for the whole thing.


What the right-click menus offer
| On a… | You can |
|---|---|
| Database | New Query, Filter Keys…, Clear Key Filter, Scan more; Bulk Edit (Delete Keys by Pattern…, Set TTL by Pattern…); Import / Export (Import Command File…, Export as Command File…); and Tools with Memory Analyzer…, Profiler…, Pub/Sub…, Server Dashboard, Activity Monitor, Query Insights, Disk Usage, and Query History. |
| Key folder | Copy SCAN Command, Scan more, Delete Keys in Folder…, Set TTL in Folder…. |
| Key | Open Value, Open in Query Tab; Rename…, Expiry (Set TTL…, Remove expiry (PERSIST)), Copy To; Copy (Copy Name, Copy Command); Delete Key…. |
| Note row | Load more, Scan more. |
The writing entries - deletes, TTL changes, renames, copies, and imports - are greyed out on a connection set to Block all but SELECT, and a locked production connection asks you to unlock writes first.
In a query tab, a Redis connection runs one command per line. Command IntelliSense completes commands, options, subcommands and key names; SQL validation and the formatter do not apply.
Read and change keys
Open a key in the key view to page through its value and edit it with the command shown first; a stream key adds tabs for its consumer groups and pending entries. In a query tab, command IntelliSense completes commands, options and key names, and Redis Stack replies come back as tables.
- Key view
- Open a key as a view: header strip, paged value, and per-type edits that show the exact command before they run.
- Streams and consumer groups
- Page through a stream, see groups, consumers, pending entries and lag, and run reviewed stream commands from the key view.
- Command IntelliSense
- Complete commands, options, subcommands and scanned key names, with syntax and safety badges on hover.
- Redis Stack modules
- JSON, Search, TimeSeries, and the probabilistic types as real grids, plus the search index browser in the explorer.
Connect to clusters and Sentinel
A connection can route commands across a Redis Cluster, including ElastiCache cluster mode and MemoryDB, or find the current master through Sentinel and follow failovers.
- Redis Cluster
- Redis Cluster, ElastiCache cluster mode and MemoryDB: slot routing, a node map for unreachable node addresses, per-node SSH forwards, and topology.
- Sentinel
- Connect through Redis Sentinel by master name, read from replicas, and survive failovers.
Watch it live
Reach for these when you need to see traffic as it happens: the Profiler to find out which client is hammering a key, the Pub/Sub viewer to check that messages are being published where you expect. Both are tabs in the Activity Monitor and run in the desktop app only.
- Profiler
- A bounded, time-boxed MONITOR capture on its own connection, with pause, filters, and a hard stop.
- Pub/Sub viewer
- Subscribe to channels, patterns, or every key event on a database and watch messages arrive live.
Look after it
Start with Tools › Disk Usage for memory per database, then the memory analyzer to see which types and keys account for it. Bulk actions clean up what you find, value formats decode what a key actually holds, and the slow log page covers the threshold that decides which commands get logged.
- Memory analyzer
- Memory by data type, the biggest keys, and a TTL histogram from a bounded sample.
- Bulk actions
- Delete or expire keys by pattern with a dry-run count first, and import command files.
- ACL users
- See every ACL user and the recent access denials, and script reviewed ACL SETUSER / ACL DELUSER changes.
- Value formats
- View a value as UTF-8, JSON, hex, MessagePack, Base64, Protobuf, or decompressed gzip, zstd and LZ4, with your pick remembered per key.
- Slow log threshold
- See the slow-log threshold and change it through a reviewed CONFIG SET.
The live tools open their own connection and always have a cap and a stop, so leaving one open cannot fill your memory or tie up the connection your queries use. The memory analyzer's sample and the bulk actions' dry-run count have a Stop too: a stopped sample keeps the previous reports on screen, and a stopped count is labelled partial.