Client on Grafana Labs

Client.decr(key)

Mon, 21 Sep 2026 15:16:28 +0000

Client.decr(key)

Decrements the number stored at key by one. If the key does not exist, it is set to zero before performing the operation.

Parameters

Parameter	Type	Description
`key`	string	the key to decrement.

Returns

Type	Resolves with	Rejected when
`Promise<number>`	On success, the promise resolves with the value of `key` after the decrement.	If the key contains a value of the wrong type, or contains a string that cannot be represented as an integer, the promise is rejected with an error.

Example

import redis from 'k6/x/redis';

// Instantiate a new redis client
const redisClient = new redis.Client('redis://localhost:6379');

export default async function () {
  await redisClient.set('mykey', 10, 0);

  let value;
  value = await redisClient.incr('mykey');
  value = await redisClient.incrBy('mykey', value);
  value = await redisClient.decrBy('mykey', value);
  value = await redisClient.decr('mykey');

  if (value !== -1) {
    throw new Error('mykey should have been -1');
  }
}

Client.decrBy(key, decrement)

Mon, 21 Sep 2026 15:16:28 +0000

Client.decrBy(key, decrement)

Decrements the number stored at key by decrement. If the key does not exist, it is set to zero before performing the operation.

Parameters

Parameter	Type	Description
`key`	string	the key to decrement.
`decrement`	number	the amount to decrement by

Returns

Type	Resolves with	Rejected when
`Promise<number>`	On success, the promise resolves with the value of `key` after the decrement.	If the key contains a value of the wrong type, or contains a string that cannot be represented as an integer, the promise is rejected with an error.

Example

import redis from 'k6/x/redis';

// Instantiate a new redis client
const redisClient = new redis.Client('redis://localhost:6379');

export default async function () {
  await redisClient.set('mykey', 10, 0);

  const value = await redisClient.decrBy('mykey', 2);
  if (value !== 8) {
    throw new Error('mykey should have been 8');
  }
}

Client.del(keys)

Mon, 21 Sep 2026 15:16:28 +0000

Client.del(keys)

Removes the specified keys. A key is ignored if it does not exist.

Parameters

Parameter	Type	Description
`keys`	string[]	the keys to delete.

Returns

Type	Resolves with	Rejected when
`Promise<number>`	On success, the promise resolves with the `number` of keys that were removed.

Example

import redis from 'k6/x/redis';

// Instantiate a new redis client
const redisClient = new redis.Client('redis://localhost:6379');

export default async function () {
  await redisClient.set('mykey', 'myvalue', 0);

  const exists = await redisClient.exists('mykey');
  if (exists === false) {
    throw new Error('mykey should exist');
  }

  const value = await redisClient.get('mykey');
  console.log(`set key 'mykey' to value: ${value}`);

  await redisClient.del('mykey');
}

Client.exists(keys)

Mon, 21 Sep 2026 15:16:28 +0000

Client.exists(keys)

Returns the number of key arguments that exist. Note that if the same existing key is mentioned in the argument multiple times, it will be counted multiple times.

Parameters

Parameter	Type	Description
`keys`	string[]	the keys to check the existence of.

Returns

Type	Resolves with	Rejected when
`Promise<number>`	On success, the promise resolves with the `number` of keys that exist from those specified as arguments.

Example

import redis from 'k6/x/redis';

// Instantiate a new redis client
const redisClient = new redis.Client('redis://localhost:6379');

export default async function () {
  let exists = await redisClient.exists('mykey');
  if (exists === true) {
    throw new Error('mykey should not exist');
  }

  await redisClient.set('mykey', 'myvalue', 0);

  exists = await redisClient.exists('mykey');
  if (exists === false) {
    throw new Error('mykey should exist');
  }

  await redisClient.del('mykey');
}

Client.expire(key, seconds)

Mon, 21 Sep 2026 15:16:28 +0000

Client.expire(key, seconds)

Sets a timeout on key, after which the key will automatically be deleted. Note that calling Expire with a non-positive timeout will result in the key being deleted rather than expired.

Parameters

Parameter	Type	Description
`key`	string	the key to set the expiration of.
`seconds`	number	the value in seconds to set the expiration to.

Returns

Type	Resolves with	Rejected when
`Promise<boolean>`	On success, the promise resolves with `true` if the timeout was set, and `false` if the timeout wasn’t set.

Example

import redis from 'k6/x/redis';

// Instantiate a new redis client
const redisClient = new redis.Client('redis://localhost:6379');

export default async function () {
  await redisClient.set('mykey', 'myvalue', 10);
  await redisClient.expire('mykey', 100);

  const ttl = await redisClient.ttl('mykey');
  if (ttl <= 10 || ttl >= 100) {
    throw new Error('mykey should have a ttl of 10 <= x < 100');
  }
}

Client.get(key)

Mon, 21 Sep 2026 15:16:28 +0000

Client.get(key)

Get the key’s value.

Parameters

Parameter	Type	Description
`key`	string	the name of the key to get

Returns

Type	Resolves with	Rejected when
`Promise<string>`	On success, the promise resolves with the value of the `key`.	If the key does not exist, the promise is rejected with an error.

Example

import redis from 'k6/x/redis';

// Instantiate a new redis client
const redisClient = new redis.Client('redis://localhost:6379');

export default async function () {
  await redisClient.set('mykey', 'myvalue', 0);

  const exists = await redisClient.exists('mykey');
  if (exists === false) {
    throw new Error('mykey should exist');
  }

  const value = await redisClient.get('mykey');
  console.log(`set key 'mykey' to value: ${value}`);

  await redisClient.del('mykey');
}

Client.getDel(key)

Mon, 21 Sep 2026 15:16:28 +0000

Client.getDel(key)

Get the value of key and delete the key. This functionality is similar to get, except for the fact that it also deletes the key on success.

Parameters

Parameter	Type	Description
`key`	string	the key to get and delete

Returns

Type	Resolves with	Rejected when
`Promise<string>`	On success, the promise resolves with the value of `key`.	If the key does not exist, the promise is rejected with an error.

Example

import redis from 'k6/x/redis';

// Instantiate a new redis client
const redisClient = new redis.Client('redis://localhost:6379');

export default async function () {
  await redisClient.set('mykey', 'oldvalue', 0);
  let value = await redisClient.getSet('mykey', 'newvalue');

  value = await redisClient.getDel('mykey');
  if (value !== 'newvalue') {
    throw new Error('mykey should have been newvalue');
  }
}

Client.getSet(key, value)

Mon, 21 Sep 2026 15:16:28 +0000

Client.getSet(key, value)

Atomically sets key to value and returns the value previously stored at key.

Parameters

Parameter	Type	Description
`key`	string	the key to get and set
`value`	string, number, or boolean	the value to set

Returns

Type	Resolves with	Rejected when
`Promise<string>`	On success, the promise resolves with the old value stored at `key`.	If `key` does not exist, or does not hold a string value, the promise is rejected with an error.

Example

import redis from 'k6/x/redis';

// Instantiate a new redis client
const redisClient = new redis.Client('redis://localhost:6379');

export default async function () {
  await redisClient.set('mykey', 'oldvalue', 0);
  await redisClient.getSet('mykey', 'newvalue');
  await redisClient.getDel('mykey');
}

Client.hdel(key, fields)

Mon, 21 Sep 2026 15:16:28 +0000

Client.hdel(key, fields)

Deletes the specified fields from the hash stored at key. The number of fields that were removed from the hash is returned on resolution (non including non existing fields).

Parameters

Parameter	Type	Description
`key`	string	key holding the hash to delete the fields of.
`fields`	string[]	fields to delete from the hash.

Returns

Type	Resolves with	Rejected when
`Promise<number>`	On success, the promise resolves with the number of fields that were removed from the hash, not including specified, but non existing, fields.

Example

import redis from 'k6/x/redis';

// Instantiate a new redis client
const redisClient = new redis.Client('redis://localhost:6379');

export default async function () {
  await redisClient.hset('myhash', 'myfield', 'myvalue');
  await redisClient.hget('myhash', 'myfield');
  await redisClient.hdel('myhash', 'myfield');
}

Client.hget(key, field)

Mon, 21 Sep 2026 15:16:28 +0000

Client.hget(key, field)

Returns the value associated with field in the hash stored at key.

Parameters

Parameter	Type	Description
`key`	string	key holding the hash to get the field of.
`field`	string	field to get from the hash.

Returns

Type	Resolves with	Rejected when
`Promise<string>`	On success, the promise resolves with the value associated with `field`.	If the hash does not exist, the promise is rejected with an error.

Example

import redis from 'k6/x/redis';

// Instantiate a new redis client
const redisClient = new redis.Client('redis://localhost:6379');

export default async function () {
  await redisClient.hset('myhash', 'myfield', 'myvalue');
  await redisClient.hget('myhash', 'myfield');
  await redisClient.hdel('myhash', 'myfield');
}

Client.hgetall(key)

Mon, 21 Sep 2026 15:16:28 +0000

Client.hgetall(key)

Returns all fields and values of the hash stored at key.

Parameters

Parameter	Type	Description
`key`	string	key holding the hash to get the fields of.

Returns

Type	Resolves with	Rejected when
`Promise<[key: string]string>`	On success, the promise resolves with the list of fields and their values stored in the hash.

Example

import redis from 'k6/x/redis';

// Instantiate a new redis client
const redisClient = new redis.Client('redis://localhost:6379');

export default async function () {
  await redisClient.hset('myhash', 'myfield', 'myvalue');
  await redisClient.hset('myhash', 'myotherfield', 'myothervalue');
  const object = await redisClient.hgetall('myhash');
  console.log(`myhash has key:value pairs ${JSON.stringify(object)}`);
}

Client.hincrby(key, field, increment)

Mon, 21 Sep 2026 15:16:28 +0000

Client.hincrby(key, field, increment)

Increments the integer value of field in the hash stored at key by increment. If key does not exist, a new key holding a hash is created. If field does not exist the value is set to 0 before the operation is set to 0 before the operation is performed.

Parameters

Parameter	Type	Description
`key`	string	key holding the hash to increment the field of.
`field`	string	field to increment in the hash.
`increment`	number	amount to increment the field by.

Returns

Type	Resolves with	Rejected when
`Promise<number>`	On success, the promise resolves with the value at `field` after the increment operation.

Example

import redis from 'k6/x/redis';

// Instantiate a new redis client
const redisClient = new redis.Client('redis://localhost:6379');

export default async function () {
  await redisClient.hset('myhash', 'myfield', 10);
  await redisClient.hincrby('myhash', 'myfield', 20);
}

Client.hkeys(key)

Mon, 21 Sep 2026 15:16:28 +0000

Client.hkeys(key)

Returns all fields of the hash stored at key.

Parameters

Parameter	Type	Description
`key`	string	key holding the hash to get the fields of.

Returns

Type	Resolves with	Rejected when
`Promise<string[]>`	On success, the promise resolves with the list of fields in the hash.	If the hash does not exist, the promise is rejected with an error.

Example

import redis from 'k6/x/redis';

// Instantiate a new redis client
const redisClient = new redis.Client('redis://localhost:6379');

export default async function () {
  await redisClient.hset('myhash', 'myfield', 'myvalue');
  await redisClient.hset('myhash', 'myotherfield', 'myothervalue');

  const keys = await redisClient.hkeys('myhash');
  if (keys.length !== 2) {
    throw new Error('myhash should have 2 keys');
  }

  console.log(`myhash has keys ${keys}`);
}

Client.hlen(key)

Mon, 21 Sep 2026 15:16:28 +0000

Client.hlen(key)

Returns the number of fields in the hash stored at key.

Parameters

Parameter	Type	Description
`key`	string	key holding the hash to get the fields of.

Returns

Type	Resolves with	Rejected when
`Promise<number>`	On success, the promise resolves with the number of fields in the hash.	If the hash does not exist, the promise is rejected with an error.

Example

import redis from 'k6/x/redis';

// Instantiate a new redis client
const redisClient = new redis.Client('redis://localhost:6379');

export default async function () {
  await redisClient.hset('myhash', 'myfield', 10);
  await redisClient.hset('myhash', 'myotherfield', 20);
  await redisClient.hlen('myhash');
}

Client.hset(key, field, value)

Mon, 21 Sep 2026 15:16:28 +0000

Client.hset(key, field, value)

Sets the specified field in the hash stored at key to value. If the key does not exist, a new key holding a hash is created. If field already exists in the hash, it is overwritten.

Parameters

Parameter	Type	Description
`key`	string	key holding the hash to set the field of.
`field`	string	field to set in the hash.
`value`	string	value to set the field to.

Returns

Type	Resolves with	Rejected when
`Promise<number>`	On success, the promise resolves with the number of fields that were added.	If the hash does not exist, the promise is rejected with an error.

Example

import redis from 'k6/x/redis';

// Instantiate a new redis client
const redisClient = new redis.Client('redis://localhost:6379');

export default async function () {
  await redisClient.hset('myhash', 'myfield', 'myvalue');
  await redisClient.hget('myhash', 'myfield');
  await redisClient.hdel('myhash', 'myfield');
}

Client.hsetnx(key, field, value)

Mon, 21 Sep 2026 15:16:28 +0000

Client.hsetnx(key, field, value)

Sets the specified field in the hash stored at key to value, only if field does not yet exist. If key does not exist, a new key holding a hash is created. If field already exists, this operation has no effect.

Parameters

Parameter	Type	Description
`key`	string	key holding the hash to set the field of.
`field`	string	field to set in the hash.
`value`	string	value to set the field to.

Returns

Type	Resolves with	Rejected when
`Promise<boolean>`	On success, the promise resolves with `1` if `field` is a new field in the hash and value was set, and with `0` if `field` already exists in the hash and no operation was performed.

Example

import redis from 'k6/x/redis';

// Instantiate a new redis client
const redisClient = new redis.Client('redis://localhost:6379');

export default async function () {
  await redisClient.hsetnx('myhash', 'myfield', 'myvalue');
  await redisClient.hsetnx('myhash', 'myotherfield', 'myothervalue');

  const set = await redisClient.hsetnx('myhash', 'myfield', 'mynewvalue');
  if (set === true) {
    throw new Error('hsetnx should have failed on existing field');
  }
}

Client.hvals(key)

Mon, 21 Sep 2026 15:16:28 +0000

Client.hvals(key)

Returns all values of the hash stored at key.

Parameters

Parameter	Type	Description
`key`	string	key holding the hash to get the fields of.

Returns

Type	Resolves with	Rejected when
`Promise<string[]>`	On success, the promise resolves with the list of values in the hash.	If the hash does not exist, the promise is rejected with an error.

Example

import redis from 'k6/x/redis';

// Instantiate a new redis client
const redisClient = new redis.Client('redis://localhost:6379');

export default async function () {
  await redisClient.hset('myhash', 'myfield', 'myvalue');
  await redisClient.hset('myhash', 'myotherfield', 'myothervalue');

  const values = await redisClient.hvals('myhash');
  if (values.length !== 2) {
    throw new Error('myhash should have 2 values');
  }

  console.log(`myhash has values ${values}`);
}

Client.incr(key)

Mon, 21 Sep 2026 15:16:28 +0000

Client.incr(key)

Increments the number stored at key by one. If the key does not exist, it is set to zero before performing the operation.

Parameters

Parameter	Type	Description
`key`	string	the key to increment

Returns

Type	Resolves with	Rejected when
`Promise<number>`	On success, the promise resolves with the value of `key` after the increment.	If the key contains a value of the wrong type, or contains a string that cannot be represented as an integer, the promise is rejected with an error.

Example

import redis from 'k6/x/redis';

// Instantiate a new redis client
const redisClient = new redis.Client('redis://localhost:6379');

export default async function () {
  await redisClient.set('mykey', 10, 0);

  let value = await redisClient.incr('mykey');
  value = await redisClient.incrBy('mykey', value);
  value = await redisClient.decrBy('mykey', value);
  value = await redisClient.decr('mykey');
  if (value !== -1) {
    throw new Error('mykey should have been -1');
  }
}

Client.incrBy(key, increment)

Mon, 21 Sep 2026 15:16:28 +0000

Client.incrBy(key, increment)

Increments the number stored at key by increment. If the key does not exist, it is set to zero before performing the operation.

Parameters

Parameter	Type	Description
`key`	string	the key to increment
`increment`	number	the amount to increment by

Returns

Type	Resolves with	Rejected when
`Promise<number>`	On success, the promise resolves with the value of `key` after the increment.	If the key contains a value of the wrong type, or contains a string that cannot be represented as an integer, the promise is rejected with an error.

Example

import redis from 'k6/x/redis';

// Instantiate a new redis client
const redisClient = new redis.Client('redis://localhost:6379');

export default async function () {
  await redisClient.set('mykey', 10, 0);

  let value = await redisClient.incr('mykey');
  value = await redisClient.incrBy('mykey', value);
  value = await redisClient.decrBy('mykey', value);
  value = await redisClient.decr('mykey');
  if (value !== -1) {
    throw new Error('mykey should have been -1');
  }
}

Client.lindex(key)

Mon, 21 Sep 2026 15:16:28 +0000

Client.lindex(key)

Returns the specified element of the list stored at key. The index is zero-based. Negative indices can be used to designate elements starting at the tail of the list.

Parameters

Parameter	Type	Description
`key`	string	key holding the list to get the element of.

Returns

Type	Resolves with	Rejected when
`Promise<string>`	On success, the promise resolves with the requested element.	If the list does not exist, or the index is out of bounds, the promise is rejected with an error.

Example

import redis from 'k6/x/redis';

// Instantiate a new redis client
const redisClient = new redis.Client('redis://localhost:6379');

export default async function () {
  await redisClient.rpush('mylist', 'first');
  await redisClient.rpush('mylist', 'second');
  await redisClient.rpush('mylist', 'third');

  const item = await redisClient.lindex('mylist', 0);
  if (item !== 'first') {
    throw new Error('lindex operation should have returned first');
  }

  await redisClient.lrange('mylist', 1, 2);
}

Client.llen(key)

Mon, 21 Sep 2026 15:16:28 +0000

Client.llen(key)

Returns the length of the list stored at key. If key does not exist, it is interpreted as an empty list and 0 is returned.

Parameters

Parameter	Type	Description
`key`	string	key holding the list to get the length of.

Returns

Type	Resolves with	Rejected when
`Promise<number>`	On success, the promise resolves with the length of the list at `key`.	If the list does not exist, the promise is rejected with an error.

Example

import redis from 'k6/x/redis';

// Instantiate a new redis client
const redisClient = new redis.Client('redis://localhost:6379');

export default function () {
  redisClient
    .rpush('mylist', 'first')
    .then((_) => redisClient.rpush('mylist', 'second'))
    .then((_) => redisClient.rpush('mylist', 'third'))
    .then((_) => redisClient.llen('mylist'))
    .then((length) => {
      if (length !== 3) {
        throw new Error('llen operations should have returned 3');
      }
    });
}

Client.lpop(key)

Mon, 21 Sep 2026 15:16:28 +0000

Client.lpop(key)

Removes and returns the first element of the list stored at key.

Parameters

Parameter	Type	Description
`key`	string	key holding the list to left pop from.

Returns

Type	Resolves with	Rejected when
`Promise<string>`	On success, the promise resolves with the value of the first element.	If the list does not exist, the promise is rejected with an error.

Example

import redis from 'k6/x/redis';

// Instantiate a new redis client
const redisClient = new redis.Client('redis://localhost:6379');

export default async function () {
  await redisClient.lpush('mylist', 'first');
  await redisClient.rpush('mylist', 'second');

  const item = await redisClient.lpop('mylist');
  await redisClient.rpush('mylist', item);
  await redisClient.rpop('mylist');
}

Client.lpush(key, values)

Mon, 21 Sep 2026 15:16:28 +0000

Client.lpush(key, values)

Inserts all the specified values at the head of the list stored at key. If key does not exist, it is created as empty list before performing the push operations.

Parameters

Parameter	Type	Description
`key`	string	key holding the list to left push to.
`values`	a variadic array of strings, numbers, or booleans	values to push to the list.

Returns

Type	Resolves with	Rejected when
`Promise<number>`	On success, the promise resolves with the length of the list after the push.	When `key` holds a value that is not a list, the promise is rejected with an error.

Example

import redis from 'k6/x/redis';

// Instantiate a new redis client
const redisClient = new redis.Client('redis://localhost:6379');

export default async function () {
  await redisClient.lpush('mylist', 'first');
  await redisClient.rpush('mylist', 'second');

  let item = await redisClient.lpop('mylist');
  item = redisClient.rpush('mylist', item);
  item = redisClient.rpop('mylist');
}

Client.lrange(key, start, stop)

Mon, 21 Sep 2026 15:16:28 +0000

Client.lrange(key, start, stop)

Returns the specified elements of the list stored at key. The offsets start and stop are zero-based indexes. These offsets can be negative numbers, where they indicate offsets starting at the end of the list.

Parameters

Parameter	Type	Description
`key`	string	key holding the list to get the range of.
`start`	number	index of the first element to return.
`stop`	number	index of the last element to return.

Returns

Type	Resolves with	Rejected when
`Promise<string[]>`	On success, the promise resolves with the list of elements in the specified range.

Example

import redis from 'k6/x/redis';

// Instantiate a new redis client
const redisClient = new redis.Client('redis://localhost:6379');

export default async function () {
  await redisClient.rpush('mylist', 'first');
  await redisClient.rpush('mylist', 'second');
  await redisClient.rpush('mylist', 'third');

  const item = redisClient.lindex('mylist', 0);
  if (item !== 'first') {
    throw new Error('lindex operation should have returned first');
  }

  await redisClient.lrange('mylist', 1, 2);
}

Client.lrem(key, count, value)

Mon, 21 Sep 2026 15:16:28 +0000

Client.lrem(key, count, value)

Removes the first count occurrences of value from the list stored at key. If count is positive, elements are removed from the beginning of the list. If count is negative, elements are removed from the end of the list. If count is zero, all elements matching value are removed.

Parameters

Parameter	Type	Description
`key`	string	key holding the list to remove the elements of.
`count`	number	number of elements to remove.
`value`	string	value to remove from the list.

Returns

Type	Resolves with	Rejected when
`Promise<number>`	On success, the promise resolves with the number of removed elements.	If the list does not exist, the promise is rejected with an error.

Example

import redis from 'k6/x/redis';

// Instantiate a new redis client
const redisClient = new redis.Client('redis://localhost:6379');

export default async function () {
  await redisClient.rpush('mylist', 'first');
  await redisClient.rpush('mylist', 'second');
  await redisClient.rpush('mylist', 'first');
  await redisClient.rpush('mylist', 'second');
  await redisClient.lrem('mylist', 0, 'second');

  const length = await redisClient.lrem('mylist', 1, 'first');
  if (length !== 1) {
    throw new Error('lrem operations should have left 1 item behind');
  }

  await redisClient.lpop('mylist');
}

Client.lset(key, index, element)

Mon, 21 Sep 2026 15:16:28 +0000

Client.lset(key, index, element)

Sets the list element at index to element.

Parameters

Parameter	Type	Description
`key`	string	key holding the list to set the element of.
`index`	number	index of the element to set.
`element`	string	value to set the element to.

Returns

Type	Resolves with	Rejected when
`Promise<string>`	On success, the promise resolves with `OK`.	If the list does not exist, or the index is out of bounds, the promise is rejected with an error.

Example

import redis from 'k6/x/redis';

// Instantiate a new redis client
const redisClient = new redis.Client('redis://localhost:6379');

export default async function () {
  await redisClient.rpush('mylist', 'first');
  await redisClient.rpush('mylist', 'second');
  await redisClient.rpush('mylist', 'third');
  await redisClient.lset('mylist', 0, 1);
  await redisClient.lset('mylist', 1, 2);
}

Client.mget(keys)

Mon, 21 Sep 2026 15:16:28 +0000

Client.mget(keys)

Returns the values of all specified keys.

Parameters

Parameter	Type	Description
`keys`	string[]	the keys to get the values of.

Returns

Type	Resolves with	Rejected when
`Promise<any[]>`	On success, the promise resolves with the list of values at the specified keys. For every key that does not hold a string value, or does not exist, the value `null` will be returned.

Example

import redis from 'k6/x/redis';

// Instantiate a new redis client
const redisClient = new redis.Client('redis://localhost:6379');

export default async function () {
  await redisClient.set('first', 1, 0);
  await redisClient.set('second', 2, 0);
  await redisClient.set('third', 3, 0);

  const values = await redisClient.mget('first', 'second', 'third');
  console.log(`set values are: ${values}`);
}

Client.persist(key)

Mon, 21 Sep 2026 15:16:28 +0000

Client.persist(key)

Removes the existing timeout on key.

Parameters

Parameter	Type	Description
`key`	string	the key to remove the timeout of.

Returns

Type	Resolves with	Rejected when
`Promise<boolean>`	On success, the promise resolves with `true` if the timeout was removed, `false` otherwise.

Example

import redis from 'k6/x/redis';

// Instantiate a new redis client
const redisClient = new redis.Client('redis://localhost:6379');

export default async function () {
  await redisClient.set('mykey', 'myvalue', 10);
  await redisClient.expire('mykey', 100);

  const ttl = await redisClient.ttl('mykey');
  if (ttl <= 10) {
    throw new Error('mykey should have a ttl of 10 <= x < 100');
  }

  await redisClient.persist('mykey', 100);
}

Client.randomKey()

Mon, 21 Sep 2026 15:16:28 +0000

Client.randomKey()

Returns a random key.

Returns

Type	Resolves with	Rejected when
`Promise<string>`	On success, the promise resolves with the random key name.	If the database is empty, the promise is rejected with an error.

Example

import redis from 'k6/x/redis';

// Instantiate a new redis client
const redisClient = new redis.Client('redis://localhost:6379');

export default async function () {
  await redisClient.set('first', 1, 0);
  await redisClient.set('second', 2, 0);
  await redisClient.set('third', 3, 0);

  const key = await redisClient.randomKey();
  console.log(`picked random key is: ${key}`);
}

Client.rpop(key)

Mon, 21 Sep 2026 15:16:28 +0000

Client.rpop(key)

Removes and returns the last element of the list stored at key.

Parameters

Parameter	Type	Description
`key`	string	key holding the list to right pop from.

Returns

Type	Resolves with	Rejected when
`Promise<string>`	On success, the promise resolves with the value of the first element.	If the list does not exist, the promise is rejected with an error.

Example

import redis from 'k6/x/redis';

// Instantiate a new redis client
const redisClient = new redis.Client('redis://localhost:6379');

export default async function () {
  await redisClient.lpush('mylist', 'first');
  await redisClient.rpush('mylist', 'second');

  const item = await redisClient.lpop('mylist');
  await redisClient.rpush('mylist', item);
  await redisClient.rpop('mylist');
}

Client.rpush(key, values)

Mon, 21 Sep 2026 15:16:28 +0000

Client.rpush(key, values)

Inserts all the specified values at the tail of the list stored at key. If key does not exist, it is created as empty list before performing the push operation.

Parameters

Parameter	Type	Description
`key`	string	key holding the list to right push to.
`values`	a variadic array of strings, numbers, or booleans	values to push to the list.

Returns

Type	Resolves with	Rejected when
`Promise<number>`	On success, the promise resolves with the length of the list after the push operation.	When `key` holds a value that is not a list, the promise is rejected with an error.

Example

import redis from 'k6/x/redis';

// Instantiate a new redis client
const redisClient = new redis.Client('redis://localhost:6379');

export default async function () {
  await redisClient.lpush('mylist', 'first');
  await redisClient.rpush('mylist', 'second');

  const item = await redisClient.lpop('mylist');
  await redisClient.rpush('mylist', item);
  await redisClient.rpop('mylist');
}

Client.sadd(key, members)

Mon, 21 Sep 2026 15:16:28 +0000

Client.sadd(key, members)

Adds the specified members to the set stored at key. Specified members that are already a member of this set are ignored. If key does not exist, a new set is created before adding the specified members.

Parameters

Parameter	Type	Description
`key`	string	key holding the set to add the members to.
`members`	a variadic array of strings, numbers, or booleans	members to add to the set.

Returns

Type	Resolves with	Rejected when
`Promise<number>`	On success, the promise resolves with the number of elements that were added to the set, not including elements already present in the set.

Example

import redis from 'k6/x/redis';

// Instantiate a new redis client
const redisClient = new redis.Client('redis://localhost:6379');

export default async function () {
  await redisClient.sadd('myset', 'foo');
  await redisClient.sadd('myset', 'bar');

  const isit = await redisClient.sismember('myset', 'foo');
  if (isit === false) {
    throw new Error('sismember should have returned true');
  }
}

Client.sendCommand(command, args)

Mon, 21 Sep 2026 15:16:28 +0000

Client.sendCommand(command, args)

In the event a Redis command you wish to use is not implemented yet, the sendCommand method can be used to send a custom commands to the server.

Parameters

Parameter	Type	Description
`command`	string	command name to issue to the Redis server, as described in Redis’ documentation.
`args`	a variadic array of strings, numbers, or booleans	command arguments to pass to the Redis server.

Returns

Type	Resolves with	Rejected when
`Promise<any>`	On success, the promise resolves with string, number, or boolean result the server would reply to the command sent.

Example

import redis from 'k6/x/redis';

// Instantiate a new redis client
const redisClient = new redis.Client('redis://localhost:6379');

export default async function () {
  const result = await redisClient.sendCommand('ECHO', 'Hello world');
  if (result !== 'Hello world') {
    throw new Error('ECHO should have returned "Hello world"');
  }
}

Client.set(key, value, expiration)

Mon, 21 Sep 2026 15:16:28 +0000

Client.set(key, value, expiration)

Set the value of a key, with a time to live equal to the expiration time parameter (in seconds). If the key already holds a value, it is overwritten.

Parameters

Parameter	Type	Description
`key`	string	the key to set
`value`	string, number, or boolean	the value to set
`expiration`	integer	the time to live in seconds. the `0` value indicates no expiration.

Returns

Type	Resolves with	Rejected when
`Promise<string>`	On success, the promise resolves with ‘OK’.	If the provided `value` is not of a supported type, the promise is rejected with an error.

Example

import redis from 'k6/x/redis';

// Instantiate a new redis client
const redisClient = new redis.Client('redis://localhost:6379');

export default async function () {
  await redisClient.set('mykey', 'myvalue', 0);

  const exists = await redisClient.exists('mykey');
  if (exists === false) {
    throw new Error('mykey should exist');
  }

  const value = await redisClient.get('mykey');
  console.log(`set key 'mykey' to value: ${value}`);

  await redisClient.del('mykey');
}

Client.sismember(key, member)

Mon, 21 Sep 2026 15:16:28 +0000

Client.sismember(key, member)

Returns if member is a member of the set stored at key.

Parameters

Parameter	Type	Description
`key`	string	key holding the set to check if the member is a member of.
`member`	string, number, or boolean	member to check if is a member of the set.

Returns

Type	Resolves with	Rejected when
`Promise<boolean>`	On success, the promise resolves with `true` if the element is a member of the set, `false` otherwise.

Example

import redis from 'k6/x/redis';

// Instantiate a new redis client
const redisClient = new redis.Client('redis://localhost:6379');

export default async function () {
  await redisClient.sadd('myset', 'foo');
  await redisClient.sadd('myset', 'bar');

  const isit = await redisClient.sismember('myset', 'foo');
  if (isit === false) {
    throw new Error('sismember should have returned true');
  }
}

Client.smembers(key)

Mon, 21 Sep 2026 15:16:28 +0000

Client.smembers(key)

Returns all the members of the set values stored at keys.

Parameters

Parameter	Type	Description
`key`	string	key holding the set to get the members of.

Returns

Type	Resolves with	Rejected when
`Promise<string[]>`	On success, the promise resolves with an array containing the values present in the set.

Example

import redis from 'k6/x/redis';

// Instantiate a new redis client
const redisClient = new redis.Client('redis://localhost:6379');

export default async function () {
  await redisClient.sadd('myset', 'foo');
  await redisClient.sadd('myset', 'bar');
  await redisClient.sadd('myset', 'foo');

  const members = await redisClient.smembers('myset');
  if (members.length !== 2) {
    throw new Error('sismember should have length 2');
  }
}

Client.spop(key)

Mon, 21 Sep 2026 15:16:28 +0000

Client.spop(key)

Removes and returns a random element from the set value stored at key.

Parameters

Parameter	Type	Description
`key`	string	The key value holding the set to get a random member of.

Returns

Type	Resolves with	Rejected when
`Promise<string>`	On success, the promise resolves to the returned set member.	If the set doesn’t exist, the promise is rejected with an error.

Example

import redis from 'k6/x/redis';

// Instantiate a new redis client
const redisClient = new redis.Client('redis://localhost:6379');

export default async function () {
  await redisClient.sadd('myset', 'foo');
  await redisClient.sadd('myset', 'bar');
  await redisClient.spop('myset');

  const members = await redisClient.smembers('myset');
  if (members.length !== 1) {
    throw new Error('sismember should have length 1');
  }
}

Client.srandmember(key)

Mon, 21 Sep 2026 15:16:28 +0000

Client.srandmember(key)

Returns a random element from the set value stored at key.

Parameters

Parameter	Type	Description
`key`	string	The key value holding the set to get a random member of.

Returns

Type	Resolves with	Rejected when
`Promise<string>`	On success, the promise resolves with the selected random member.	If the set doesn’t exist, the promise is rejected with an error.

Example

import redis from 'k6/x/redis';

// Instantiate a new redis client
const redisClient = new redis.Client('redis://localhost:6379');

export default async function () {
  await redisClient.sadd('myset', 'foo');
  await redisClient.sadd('myset', 'bar');

  const randomMember = await redisClient.srandmember('myset');
  if (randomMember !== 'foo' && randomMember !== 'bar') {
    throw new Error('randomMember should be equal to "foo" or "bar"');
  }
}

Client.srem(key, members)

Mon, 21 Sep 2026 15:16:28 +0000

Client.srem(key, members)

Removes the specified members from the set stored at key. Specified members that are not a member of this set are ignored. If key does not exist, it is treated as an empty set and this command returns 0.

Parameters

Parameter	Type	Description
`key`	string	key holding the set to remove the members from.
`members`	a variadic array of strings, numbers, or booleans	members to remove from the set.

Returns

Type	Resolves with	Rejected when
`Promise<number>`	On success, the promise resolves with the number of members that were remove from the set, not including non existing members.

Example

import redis from 'k6/x/redis';

// Instantiate a new redis client
const redisClient = new redis.Client('redis://localhost:6379');

export default async function () {
  await redisClient.sadd('myset', 'foo');
  await redisClient.sadd('myset', 'bar');
  await redisClient.srem('myset', 'foo');

  const members = await redisClient.smembers('myset');
  if (members.length !== 1) {
    throw new Error('sismember should have length 1');
  }
}

Client.ttl(key)

Mon, 21 Sep 2026 15:16:28 +0000

Client.ttl(key)

Returns the remaining time to live of a key that has a timeout.

Parameters

Parameter	Type	Description
key	string	the key to get the TTL of.

Returns

Type	Resolves with	Rejected when
`Promise<number>`	On success, the promise resolves with the TTL value in seconds.

Example

import redis from 'k6/x/redis';

// Instantiate a new redis client
const redisClient = new redis.Client('redis://localhost:6379');

export default async function () {
  await redisClient.set('mykey', 'myvalue', 10);
  await redisClient.expire('mykey', 100);

  const ttl = await redisClient.ttl('mykey');
  if (ttl <= 10) {
    throw new Error('mykey should have a ttl of 10 <= x < 100');
  }

  await redisClient.persist('mykey', 100);
}