A demo benchmark between Redis Cloud and Upstash Redis, as published on https://www.xadd.dev/comparison/upstash-vs-redis-cloud-a-2026-comparison

bench.mjs

import Redis from "ioredis";
import { readFileSync } from "node:fs";
import { execSync } from "node:child_process";
import { hostname } from "node:os";

// Configure via env vars:
//   UPSTASH_REDIS_TLS_URL=rediss://default:<token>@<host>:<port>
//   REDIS_CLOUD_TLS_URL=rediss://default:<password>@<host>:<port>
//   REDIS_CLOUD_CA_FILE=./redis_ca.pem  (optional, defaults to ./redis_ca.pem)
const TARGETS = [
  {
    name: "Upstash TCP (TLS)",
    url: process.env.UPSTASH_REDIS_TLS_URL,
    caFile: null,
  },
  {
    name: "Redis Cloud TCP (TLS, private CA)",
    url: process.env.REDIS_CLOUD_TLS_URL,
    caFile: process.env.REDIS_CLOUD_CA_FILE || "./redis_ca.pem",
  },
];

const N = 2000;
const WARMUP = 200;
const CONCURRENT_N = 200;
const KEY = "bench:key";

function pct(arr, p) {
  const s = [...arr].sort((a, b) => a - b);
  const i = Math.min(s.length - 1, Math.floor(p * s.length));
  return s[i];
}

function stats(samples) {
  const sum = samples.reduce((a, b) => a + b, 0);
  return {
    n: samples.length,
    mean: sum / samples.length,
    p50: pct(samples, 0.5),
    p90: pct(samples, 0.9),
    p95: pct(samples, 0.95),
    p99: pct(samples, 0.99),
    min: Math.min(...samples),
    max: Math.max(...samples),
  };
}

async function timed(fn) {
  const t = process.hrtime.bigint();
  await fn();
  return Number(process.hrtime.bigint() - t) / 1e6;
}

async function runSeq(fn) {
  for (let i = 0; i < WARMUP; i++) await fn(i);
  const samples = [];
  for (let i = 0; i < N; i++) samples.push(await timed(() => fn(i)));
  return stats(samples);
}

async function runConcurrentGets(client, n) {
  for (let i = 0; i < WARMUP; i++) await client.get(KEY);
  const t = process.hrtime.bigint();
  await Promise.all(Array.from({ length: n }, () => client.get(KEY)));
  const ms = Number(process.hrtime.bigint() - t) / 1e6;
  return { totalMs: ms, opsPerSec: n / (ms / 1000), n };
}

function maskUrl(url) {
  try {
    const u = new URL(url);
    return `${u.protocol}//***@${u.hostname}:${u.port}`;
  } catch {
    return "<invalid url>";
  }
}

async function benchTarget({ name, url, caFile }) {
  console.error(`\n== ${name} ==`);
  const opts = { lazyConnect: true, maxRetriesPerRequest: 3, connectTimeout: 5000 };
  if (caFile) {
    opts.tls = { ca: readFileSync(caFile) };
  }
  const client = new Redis(url, opts);
  try {
    await client.connect();
  } catch (e) {
    console.error(`  ! connect failed: ${e.message}`);
    return null;
  }
  await client.set(KEY, "value");

  const results = {};
  results.GET = await runSeq(() => client.get(KEY));
  console.error(`  GET   p50=${results.GET.p50.toFixed(2)} p99=${results.GET.p99.toFixed(2)}`);

  results.SET = await runSeq((i) => client.set(KEY, `v${i}`));
  console.error(`  SET   p50=${results.SET.p50.toFixed(2)} p99=${results.SET.p99.toFixed(2)}`);

  results.INCR = await runSeq(() => client.incr("bench:ctr"));
  console.error(`  INCR  p50=${results.INCR.p50.toFixed(2)} p99=${results.INCR.p99.toFixed(2)}`);

  results["Pipeline x10 SETs"] = await runSeq((i) => {
    const p = client.pipeline();
    for (let j = 0; j < 10; j++) p.set(`bench:p:${j}`, `v${i}-${j}`);
    return p.exec();
  });
  console.error(`  PIPE  p50=${results["Pipeline x10 SETs"].p50.toFixed(2)} p99=${results["Pipeline x10 SETs"].p99.toFixed(2)}`);

  results["Rate-limit (INCR+EXPIRE pipelined)"] = await runSeq((i) => {
    const p = client.pipeline();
    p.incr("bench:rl:" + (i % 50));
    p.expire("bench:rl:" + (i % 50), 60);
    return p.exec();
  });
  console.error(`  RL    p50=${results["Rate-limit (INCR+EXPIRE pipelined)"].p50.toFixed(2)} p99=${results["Rate-limit (INCR+EXPIRE pipelined)"].p99.toFixed(2)}`);

  const conc = await runConcurrentGets(client, CONCURRENT_N);
  results[`${CONCURRENT_N} concurrent GETs`] = conc;
  console.error(`  ${CONCURRENT_N}xGET ${Math.round(conc.opsPerSec).toLocaleString()} ops/sec`);

  await client.quit();
  return { name, urlMasked: maskUrl(url), caFile: caFile || null, results };
}

function fetchImds(path) {
  try {
    const token = execSync(`curl -s -X PUT "http://169.254.169.254/latest/api/token" -H "X-aws-ec2-metadata-token-ttl-seconds: 60"`, { timeout: 2000 }).toString().trim();
    return execSync(`curl -s -H "X-aws-ec2-metadata-token: ${token}" "http://169.254.169.254/latest/meta-data/${path}"`, { timeout: 2000 }).toString().trim();
  } catch {
    return null;
  }
}

const env = {
  timestamp: new Date().toISOString(),
  hostname: hostname(),
  node: process.version,
  ioredis: JSON.parse(readFileSync("./package.json")).dependencies.ioredis,
  platform: process.platform,
  arch: process.arch,
  ec2: {
    instanceId: fetchImds("instance-id"),
    instanceType: fetchImds("instance-type"),
    availabilityZone: fetchImds("placement/availability-zone"),
    region: fetchImds("placement/region"),
    ami: fetchImds("ami-id"),
  },
  bench: {
    sequentialOpsPerTest: N,
    warmupOpsPerTest: WARMUP,
    concurrentGets: CONCURRENT_N,
    timingSource: "process.hrtime.bigint()",
    percentileMethod: "sort ascending, floor(p*n) index",
  },
};

console.error("\n== environment ==");
console.error(JSON.stringify(env, null, 2));

const out = [];
for (const t of TARGETS) {
  if (!t.url) {
    console.error(`Skipping ${t.name} - URL not set`);
    continue;
  }
  const r = await benchTarget(t);
  if (r) out.push(r);
}

const result = { env, targets: out };
process.stdout.write(JSON.stringify(result, null, 2));

results.csv

summary.md

Results Summary — Upstash TCP vs Redis Cloud TCP, TLS on both sides, us-east-1

Run timestamp: 2026-05-19 (~12:51 UTC) Client: c7i.large EC2, Node 22.22.3, ioredis 5.7.0 TLS: enabled on both providers

• Upstash: publicly-trusted CA (zero client config)
• Redis Cloud: private CA, tls: { ca: fs.readFileSync('redis_ca.pem') } passed to ioredis Sample size: 2000 sequential ops per workload, 200 warmup ops, 1 client per provider per run

p50 latency by AZ (ms)

Workload	Provider	us-east-1a	us-east-1b	us-east-1c
GET	Upstash	1.53	0.78	1.28
GET	Redis Cloud	1.40	0.48	1.07
SET	Upstash	1.50	0.80	1.26
SET	Redis Cloud	1.39	0.46	1.08
INCR	Upstash	1.49	0.76	1.21
INCR	Redis Cloud	1.38	0.47	1.04
Pipeline x10 SETs	Upstash	1.53	0.86	1.28
Pipeline x10 SETs	Redis Cloud	1.45	0.49	1.10
Rate-limit (INCR+EXPIRE pipelined)	Upstash	1.49	0.76	1.26
Rate-limit (INCR+EXPIRE pipelined)	Redis Cloud	1.41	0.50	1.06

p99 latency by AZ (ms)

Workload	Provider	us-east-1a	us-east-1b	us-east-1c
GET	Upstash	2.30	1.22	2.06
GET	Redis Cloud	3.02	1.85	1.37
SET	Upstash	2.07	1.29	1.83
SET	Redis Cloud	1.80	0.85	2.95
INCR	Upstash	2.24	1.14	1.84
INCR	Redis Cloud	1.61	0.89	1.27
Pipeline x10 SETs	Upstash	2.54	1.29	2.05
Pipeline x10 SETs	Redis Cloud	1.92	0.90	1.58
Rate-limit (INCR+EXPIRE pipelined)	Upstash	1.85	1.21	1.94
Rate-limit (INCR+EXPIRE pipelined)	Redis Cloud	1.67	1.09	1.29

200 concurrent GETs through 1 connection (ops/sec)

Provider	us-east-1a	us-east-1b	us-east-1c
Upstash	48,458	108,163	74,911
Redis Cloud	89,949	132,652	134,349

Median across the 3 AZs (single-number-per-cell summary)

Workload	Upstash p50	Upstash p99	Redis Cloud p50	Redis Cloud p99
GET	1.28 ms	2.06 ms	1.07 ms	1.85 ms
SET	1.26 ms	1.83 ms	1.08 ms	1.80 ms
INCR	1.21 ms	1.84 ms	1.04 ms	1.27 ms
Pipeline x10 SETs	1.28 ms	2.05 ms	1.10 ms	1.58 ms
Rate-limit (INCR+EXPIRE pipelined)	1.26 ms	1.85 ms	1.06 ms	1.29 ms
200 concurrent GETs	74,911 ops/sec	—	132,652 ops/sec	—