How to Integrate Retool with Redis

Redis is typically deployed in a private network and should not be exposed directly to the internet. Before creating the Retool resource, ensure Retool's servers can reach your Redis port. For Redis Cloud: log into your Redis Cloud console, navigate to your database's Configuration settings, and add Retool's IP ranges to the allowed CIDR list. For AWS ElastiCache: modify the security group associated with your ElastiCache cluster to add an inbound rule for port 6379 from Retool's IP ranges (35.90.103.132/30 and 44.208.168.68/30 for US West). For Upstash: Upstash Redis allows connections from any IP by default with TLS and token-based authentication, so no IP whitelisting is needed — just enable TLS in your Retool resource. For self-hosted Redis behind a corporate firewall: use SSH tunneling through a bastion host (configured in the Retool resource settings) rather than opening the Redis port to the internet. For self-hosted Retool in the same VPC as Redis: use the private IP address or hostname directly — no firewall changes needed.

In Retool, go to the Resources tab and click '+ Create new resource'. Select 'Redis' from the connector list. On the configuration screen, fill in: Name — something descriptive like 'Redis Cache (Production)' or 'Redis Session Store'. Host — the hostname or IP of your Redis instance. For ElastiCache, this is the Primary Endpoint (e.g., my-cluster.xxxxx.use1.cache.amazonaws.com). For Redis Cloud, use the provided endpoint. For Upstash, copy the endpoint from your Upstash database dashboard. Port — the Redis port, defaulting to 6379. Upstash Redis uses port 6379 for standard connections and 6380 for TLS connections. Password — the Redis AUTH password. For ElastiCache without AUTH enabled, leave this blank. For Redis Cloud and Upstash, use the password shown in your database's security settings. Database index — Redis supports 16 logical databases (0-15) by default. Enter 0 unless your application uses a specific database number. Toggle 'Use TLS' on for any cloud-hosted Redis instance (Redis Cloud, Upstash, ElastiCache with in-transit encryption). Click 'Test connection' — a successful connection shows the Redis server version. Click Save.

Open your Retool app and create a new query in the Code panel. Select your Redis resource. The Redis query editor shows a Command field and an Arguments section. In the Command field, type the Redis command in uppercase — GET, SET, KEYS, DEL, TTL, TYPE, EXPIRE, HGETALL, etc. In the Arguments section, add each argument as a separate field. For a GET command: Command = GET, Argument 1 = the key name or a dynamic expression like session:{{ userIdInput.value }}. For a KEYS command: Command = KEYS, Argument 1 = a glob pattern like product:* or *. For HGETALL: Command = HGETALL, Argument 1 = the hash key name. Click Run to execute. The response appears in the query editor's result panel. For KEYS with a wildcard pattern, the result is an array of matching key names. For GET, it is a string value or null. For HGETALL, it is an object with field-value pairs. Create multiple queries for the different Redis operations your app needs — a common pattern is a scanKeys query, a getValue query, and a getTTL query, all referencing the same selected key from a table.

1// Redis query configuration examples
2// Set Command and Arguments in the query editor UI
3
4// --- GET a single key ---
5// Command: GET
6// Argument 1: {{ keyInput.value }}
7
8// --- KEYS by pattern ---
9// Command: KEYS
10// Argument 1: {{ patternInput.value || 'session:*' }}
11
12// --- HGETALL a hash key ---
13// Command: HGETALL
14// Argument 1: {{ table1.selectedRow.key }}
15
16// --- TTL of a key ---
17// Command: TTL
18// Argument 1: {{ table1.selectedRow.key }}
19
20// --- EXPIRE to reset TTL ---
21// Command: EXPIRE
22// Argument 1: {{ table1.selectedRow.key }}
23// Argument 2: 3600

The KEYS command returns all matching keys in a single blocking call — on Redis instances with large keyspaces, this can cause latency spikes. The safer approach is SCAN, which iterates keys in cursor-based batches. In Retool, use a JavaScript query to implement a SCAN loop that collects keys matching your pattern. Create a JS query in the Code panel (select resource type as 'JavaScript' rather than Redis), then use utils.executeQuery() to call your Redis resource's SCAN command iteratively. Each SCAN call returns [nextCursor, [keys]] — continue iterating until the cursor returns '0'. After collecting all matching keys, build a second query to fetch metadata (TYPE and TTL) for each key, either by running TYPE and TTL individually or batching with a Pipeline query. Display the collected keys in a Table component with key, type, and TTL columns. Add a search TextInput that filters the table client-side using the Table's built-in search, and a Pattern button that re-runs the SCAN with a new pattern. For the TTL column, format the integer (seconds) as a human-readable string using a transformer.

1// JavaScript query to SCAN all keys matching a pattern
2// Run this as a JavaScript query type (not Redis resource query)
3const pattern = patternInput.value || '*';
4const maxKeys = 500; // safety limit
5const allKeys = [];
6let cursor = '0';
7
8do {
9  const result = await utils.executeQuery('scanRedis', {
10    command: 'SCAN',
11    args: [cursor, 'MATCH', pattern, 'COUNT', '100']
12  });
13  // SCAN returns [nextCursor, [keyNames]]
14  cursor = result[0];
15  allKeys.push(...result[1]);
16} while (cursor !== '0' && allKeys.length < maxKeys);
17
18// Fetch TTL for each key (batched to avoid overloading)
19const keyData = await Promise.all(
20  allKeys.map(async (key) => {
21    const [ttl, type] = await Promise.all([
22      utils.executeQuery('getTTL', { args: [key] }),
23      utils.executeQuery('getType', { args: [key] })
24    ]);
25    return {
26      key,
27      type,
28      ttl: ttl === -1 ? 'No expiry' : ttl === -2 ? 'Expired' : `${ttl}s`
29    };
30  })
31);
32
33return keyData;

When a user clicks a key in the browser table, display its value in a detail panel. The value display depends on the key type — strings show in a Text component, hashes show in a secondary Table, lists and sets show as item arrays. Use a Container component to hold the detail panel. Add a conditional component that renders different UI based on the selected row's type field. For string values: bind a Text component to {{ getValue.data }}. For hash values: bind a secondary Table to {{ formatHash.data }} where a transformer converts HGETALL's { field: value } object into [{ field: 'name', value: 'example' }, ...] row format. For list values: bind a Table to {{ getLRange.data }} with a single value column. Add an Edit section below: a TextArea pre-populated with the current value and a Set TTL input (number field defaulting to the current TTL). Wire a Save button to a SET command query for string keys (Command: SET, Arguments: key, new value) or HSET for hash fields. Wire a Delete Key button to a DEL command query with a confirmation modal. For complex Redis data management involving Lua scripts, Streams, or cluster-mode Redis, RapidDev's team can help architect and build your Retool solution.

1// Transformer: convert HGETALL response object to array of rows
2// HGETALL returns: { "field1": "value1", "field2": "value2" }
3// Transform to: [{ field: "field1", value: "value1" }, ...]
4const hashData = data; // result of HGETALL query
5if (!hashData || typeof hashData !== 'object') return [];
6
7return Object.entries(hashData).map(([field, value]) => ({
8  field,
9  value: String(value),
10  valueLength: String(value).length
11}));