Live in production — free while in beta

One Redis layer.
Every project you ship.

Isolated namespaces, per-project API keys, and a REST endpoint for every Redis operation. No connection strings. No instance to babysit.

Start free — 1 project Read the docs

No credit card
Live in under a minute
Your data stays namespaced

cURL / checkout_svc

curl -X POST https://api.redis.mohammadramiz.in/checkout_svc/set/cart:42 \
  -H "x-api-key: sk_live_8Kd…" \
  -H "Content-Type: application/json" \
  -d '{"value": {"items": 3}, "ttl": 3600}'
# 200 OK · 11 ms
{"ok": true, "key": "cart:42", "ttl": 3600}

Built on

FastAPI
Redis
MongoDB Atlas
Python
Render

The dashboard

Everything your keys are doing, in one place.

Browse data, run requests, rotate keys, and watch usage — without opening a Redis CLI.

api.redis.mohammadramiz.in/app/checkout_svc

checkout_svc

active

Total keys

1,284

Memory used

4.2 MB

Requests 24h

18,342

Error rate

0.03%

Requests

24h7d30d

STRcart:104258m

STRsession:a91f2h

LSTqueue:emails∞

HSHorder:88∞

SETtags:live∞

{

"user_id": 1042,

"items": 3,

"currency": "usd"

}

Data Browser

Filter by pattern, inspect any key, edit JSON in place.

POST/set/cart:1042

getsetincrlpushhset

200· 14 ms · 86 B

"ok": true

"ttl": 3600

API Console

Send real requests without leaving the page.

Productionsk_live_••••••••3f9a

2 min ago

Stagingsk_live_••••••••3f9a

4 hours ago

Local devsk_live_••••••••3f9a

3 days ago

CI pipelinesk_live_••••••••3f9a

never

API Keys

Name, rotate, and revoke keys independently.

What you get

Built for the way you actually use Redis.

Every Redis primitive you reach for, exposed over HTTP and scoped to one project.

Namespaced by default

Every key is stored as project_id:key. Two projects can both use session:1 without ever seeing each other.

checkout_svc:session:1

Keys you can rotate

Up to 10 named API keys per project. Rotate or revoke one without touching the others. Stored hashed — shown once.

sk_live_••••••••3f9a

Real data types

Strings, lists, hashes, and sets. TTLs, atomic counters, batch reads and writes.

GETSETLPUSHHSETSADDINCR

Usage you can see

Request volume, error rate, and p50/p95/p99 latency per project, broken down by operation.

p50 8ms · p95 34ms

A browser for your keys

Filter by glob pattern, inspect any value, edit JSON in place. Cursor paginated, so a large keyspace stays responsive.

cart:*

Isolation that's enforced

A project's key only ever authenticates that project. Wrong project, wrong key, revoked key — all rejected at the edge.

401 Invalid API key

How it works

Three steps. Zero ops.

From signing up to storing your first key is about a minute.

Create a project

Pick an ID. You get an isolated namespace and an API key, shown once.

checkout_svcCreate

Store something

Any JSON value, with an optional TTL in seconds.

curl -X POST $BASE/set/cart:42 \
  -H "x-api-key: $KEY" \
  -d '{"value": {"items": 3}, "ttl": 3600}'

Read it back

Values round-trip as JSON. Objects come back as objects, not strings.

curl $BASE/get/cart:42 -H "x-api-key: $KEY"
{"key":"cart:42","value":{"items":3},"exists":true}

Integration

It’s just HTTP.

No client library to install, no connection pool to size, no TLS config. If your language can make an HTTP request, it can use Central Redis.

Values are stored as JSON when they parse as JSON, and as raw strings when they don’t. Reads reverse it, so what you put in is what you get back.

Full API reference

JavaScript

const BASE = "https://api.redis.mohammadramiz.in/checkout_svc";
const headers = {
  "x-api-key": process.env.CENTRAL_KEY,
  "Content-Type": "application/json"
};
// write with a one-hour TTL
await fetch(`${BASE}/set/cart:42`, {
  method: "POST",
  headers,
  body: JSON.stringify({ value: { items: 3 }, ttl: 3600 })
});
// read it back
const res = await fetch(`${BASE}/get/cart:42`, { headers });
const { value } = await res.json();  // { items: 3 }

Try it

Run a request right now.

This runs entirely in your browser — no account, nothing sent anywhere. Same request and response shapes as the real API, so set then get really does return what you stored.

POST

/sandbox

/set/demo:1

Body

Send a request to see the response.

The same call, for real

curl -X POST https://api.redis.mohammadramiz.in/checkout_svc/set/demo:1 \
 -H "x-api-key: $CENTRAL_KEY"

Nothing here is stored on a server. Create a project for a namespace that’s yours.

Create your project

Pricing

Free while we grow.

One project per account, generous limits, and no card. Paid tiers arrive when there's something worth charging for.

Available now

Free

$0/month

Everything you need for a side project or a small service.

Create your account

1 project
10,000 keys
100 MB storage
1,000,000 requests / month
10 API keys
Full dashboard, browser, and console

Limits aren’t enforced during beta. You’ll get an email well before that changes.

More than one project

Let’s talk

Multiple projects, higher limits, or something specific to your setup — send a note and we’ll sort it out.

Email the founder

Multiple projects
Raised limits
Direct support

Why this exists

“I kept spinning up a Redis instance for every side project. Same config, same connection string in another .env file, same instance sitting idle at 4am. This started as a way to stop repeating myself — one namespaced API across everything I build.”

Mohammad Ramiz

Builder — Central Redis

Running since: Apr 2026
Built with: FastAPI · Redis · MongoDB
Status: Production

Questions

Before you sign up.

Yes. Every key is stored internally as project_id:key, and a project's API key only ever authenticates that one project. Presenting a valid key for a different project returns 401.

Rotate it from the dashboard. The old value stops working immediately and you get a new one. Keys are stored hashed, so nobody — including us — can read yours back.

No. It's Redis with an HTTP layer and multi-tenancy on top. If you need Lua scripting, pub/sub, or streams, use Redis directly. If you need a key-value store for a handful of projects, this removes the setup.

Reads are sub-millisecond in Redis; what you actually measure is network latency to the API. Your real p50, p95, and p99 are on the Usage page — measured, not promised.

Strings, lists, hashes, and sets, plus TTLs and atomic counters. Sorted sets and streams aren't exposed yet.

You shouldn't. An API key in client-side JavaScript is a public API key. Call it from your server.

During beta, nothing — limits are displayed but not enforced, and you'll get an email well before that changes.

Yes. Flush a project's data or delete the project outright from the dashboard, and deleting your account removes every project and key with it.

What's next

Shipping in the open.

Here's what exists today and what's being built. No dates — they'd be fiction.

Shipped

Accounts, sessions, and roles
Per-project API keys with rotation
Data browser with pattern search
Usage metrics and latency percentiles
Admin console

In progress

Client libraries for JS and Python
Password reset and email verification
Sorted sets and streams
Higher limits and paid tiers

Later

Webhooks on key events
Pub/sub over server-sent events
Team accounts and shared projects
Regional deployments

Stop configuring Redis.

One account, one namespace, one key. Free while we’re in beta.

Create your account Read the docs

No credit card. Delete everything in one click if it isn’t for you.