A Redis-compatible store.
Free forever, period.

Connect in 3 lines

Any Redis client library works. Always over TLS, always with a token.

$ redis-cli -h nyxkv.com -p 6380 --tls -a $TOKEN
nyxkv.com:6380> SET hello world
OK

import redis
r = redis.Redis(host="nyxkv.com", port=6380, ssl=True, password="$TOKEN")
r.set("hello", "world")

import Redis from 'ioredis';
const r = new Redis({
  host: 'nyxkv.com', port: 6380,
  tls: {}, password: process.env.TOKEN,
});
await r.set('hello', 'world');

rdb := redis.NewClient(&redis.Options{
    Addr:      "nyxkv.com:6380",
    Password:  os.Getenv("TOKEN"),
    TLSConfig: &tls.Config{},
})
rdb.Set(ctx, "hello", "world", 0)

let url = format!("rediss://:{}@nyxkv.com:6380", token);
let client = redis::Client::open(url)?;
let mut con = client.get_connection()?;
redis::cmd("SET").arg("hello").arg("world").execute(&mut con);

Quick Start

From zero to storing data in under a minute.

$ redis-cli -h nyxkv.com -p 6380 --tls -a $TOKEN PING
PONG
$ redis-cli -h nyxkv.com -p 6380 --tls -a $TOKEN
nyxkv.com:6380> SET user:1:name "Alice"
OK
nyxkv.com:6380> INCR counter
(integer) 1

64 commands across 8 capabilities

Everything you reach for in a Redis-compatible store — verified against redis-py and redis-cli.

All 64 commands →

SCAN that never drops a key

A cursor-based SCAN is only useful if it keeps its promise while the keyspace changes under it. NyxKV implements Redis's reverse-binary cursor over its Robin Hood hash table, so a key present for the whole scan is returned at least once — even when writes trigger table resizes mid-iteration.

# redis-py, iterating while another client floods writes
for key in r.scan_iter(match="orig:*", count=5):
    seen.add(key)
# 100/100 runs with a concurrent writer forcing resizes: 0 keys lost

Honest numbers vs redis-server

Head-to-head on the same box (redis-benchmark, no pipeline, TLS off for the comparison). Latency sits in the same order of magnitude as Redis; the tail is where a garbage-collected runtime shows — we publish it rather than hide it.

Where does the gap go? The hot path allocates through a conservative GC, which shows up as occasional tail-latency spikes and a larger resident set. For a free, Redis-compatible endpoint it is a trade we make on purpose — and one we keep measuring.

Multi-tenant by default

Every account has its own keyspace. Tokens are issued by the dashboard, not the protocol.

# 1. Generate a token at https://dashboard.nyxkv.com/app/keys
# 2. Pass it as the password to any Redis client

$ redis-cli -h nyxkv.com -p 6380 --tls -a $TOKEN
nyxkv.com:6380> SET mykey "my data"
OK
# Stored in your namespace. No other account can read or write it.

Persistent by default

A background snapshot is written once per second. Restarts pick up where they left off.

Persistent memory for your agents

Drop-in memory for Claude Code and other agents, backed by your NyxKV token. Survives sessions, syncs across machines.

# save your token once, build the SDK, install the plugin
$ printf '%s' "$TOKEN" > ~/.nyxkv-token && cd sdk && nyx build
# then, from your agent: "pull my memory" at start, "save my memory" at the end

How Agent Memory works →

Free forever

No Pro tier. No Enterprise tier. The free tier is the product.

Built entirely with Nyx

Part of a self-hosting language ecosystem. Daemon binary: ~390KB.