How do I sign up for Redis Cloud and create my first database?

Redis Cloud makes it easy to spin up a fully managed Redis database in just a few minutes—no servers to provision, no clusters to babysit. This guide walks you step-by-step through signing up, creating your first database, and connecting from your app so you can start building low-latency features right away.

Quick Answer: You sign up for Redis Cloud with your email or cloud marketplace account (AWS, GCP, or Azure), choose a pay-as-you-go or free trial plan, then create a new database from the Redis Cloud console. The console gives you a connection string and credentials you can drop directly into your application code.

The Quick Overview

What It Is: Redis Cloud is the fully managed Redis data platform from Redis, running on AWS, Azure, and GCP. It gives you a fast memory layer for caching, real-time workloads, and AI features like vector search—without managing infrastructure.
Who It Is For: Developers and platform teams who want sub-millisecond latency, high availability, and Redis capabilities (caching, JSON, search, vector sets, AI agent memory) without running Redis themselves.
Core Problem Solved: Your primary database can’t keep up with low-latency reads and writes at scale. Redis Cloud offloads hot paths—sessions, rate limiting, leaderboards, semantic caching, RAG retrieval—so your app stays fast and your system of record stays healthy.

How It Works

At a high level, you:

Create a Redis Cloud account using email or a cloud marketplace subscription.
Provision your first database in the console: pick a cloud provider/region, choose a plan size, and enable the modules you need (e.g., RedisJSON, search, vectors).
Connect from your app using a Redis client library (Python, Node.js, Java, .NET, Go, etc.) with the TLS-secured connection string and password Redis Cloud provides.

Under the hood, Redis Cloud runs and manages Redis clusters for you—handling scaling, automatic failover, backups, and security hardening—so you just interact with Redis as a data structure server and fast memory layer.

Step 1: Sign up for Redis Cloud

Go to the Redis Cloud signup page
Visit: https://redis.io/ → navigate to Redis Cloud → choose Try for free or Start building (label may vary slightly).
Choose how to register
- Email + password: Create a new Redis Cloud account directly.
- Single sign-on (if available): Use GitHub/Google/etc. to speed up onboarding.
- Cloud marketplace (AWS/GCP/Azure):
  - On AWS, you can subscribe via AWS Marketplace. Charges are added to your AWS bill using a pay-as-you-go model, so you only pay for the GB-hours you consume with no separate invoices.
Verify your account
- Check your email for a verification link.
- Click the link to activate your Redis Cloud account.
- Log in to the Redis Cloud console.

Note: If you’re a platform/FinOps team, marketplace signup simplifies procurement and centralizes billing. For quick dev testing, the direct “try for free” path is usually fastest.

Step 2: Set up your first Redis Cloud subscription

Once you’re in the Redis Cloud console, you create a subscription that holds one or more databases.

Create a subscription
- Click Create subscription or a similarly labeled button in the console.
- Choose:
  - Cloud provider: AWS, GCP, or Azure.
  - Region: As close as possible to your application or Kubernetes cluster to minimize latency.
  - Plan type:
    - Free trial / dev-sized plan (for testing and small workloads).
    - Pay-as-you-go (scale with usage).
    - Enterprise tiers (for 24/7 production workloads, SLAs, Active-Active, etc.).
Configure high-level settings
- Memory size: Estimate based on your hot data:
  - Simple cache/session store: start small (hundreds of MB to a few GB).
  - Vector database / AI agent memory: size for embeddings + metadata.
- Performance/throughput: Some tiers let you pick performance profiles (more throughput vs. more capacity).
- High availability: For production, enable redundancy so Redis Cloud can failover automatically.

Warning: Under-sizing memory leads to eviction when you hit memory limits. That can cause unexpected cache misses or lost ephemeral data. For critical workloads, size up and monitor memory via Redis metrics and Prometheus/Grafana dashboards.

Step 3: Create your first Redis Cloud database

Within your subscription, you now create a database—this is the Redis endpoint your app will talk to.

Start database creation
- In the subscription view, click Create database.
Choose database options
- Name: e.g., app-cache, session-store, rag-vector-db.
- Protocol: Regular Redis (RESP) is the standard; you’ll use this for most clients.
- Data types / capabilities: Enable the modules your workload needs:
  - RedisJSON for JSON documents.
  - Search / vector (e.g., vector sets) for semantic search and RAG.
  - Time series if you’re tracking metrics/time-based events.
- Memory and throughput configuration: Based on expected load:
  - For early dev, a small configuration is fine.
  - For production, use your estimated QPS and data size.
Security configuration
- Ensure TLS is enabled (it typically is by default in managed environments).
- Set an access control password or user credentials.
- Restrict network access where possible (VPC peering, IP allowlisting, private networking) so your database isn’t broadly exposed.
Create the database
- Click Create and wait for the status to show as Active (or similar).

You’ll now see:

Endpoint / Host: e.g., redis-12345.c123.us-east-1-1.ec2.cloud.redislabs.com
Port: A numeric port (often 6379 or a TLS-secured port).
Password / User credentials: Store these securely (e.g., environment variables, secret manager).

Warning: Never hard-code the Redis Cloud password in your repo. Use a secrets manager or Kubernetes Secret objects, and protect access with ACLs and network policy.

Features & Benefits Breakdown

Core Feature	What It Does	Primary Benefit
Fully managed fast memory layer	Runs Redis clusters for you (HA, scaling, backups) on AWS/Azure/GCP	Offload ops and keep hot paths under sub-millisecond latency
Built-in AI & search primitives	Adds RedisJSON, full-text search, vector sets, and semantic search	Build RAG, semantic caching, and AI agent memory in one place
Flexible deployment & billing	Pay-as-you-go via cloud marketplaces or direct; deploy near your app	Aligns cost with usage while minimizing network latency

Ideal Use Cases

Best for first-time Redis users: Because Redis Cloud handles provisioning, scaling, and failover, you can learn Redis data structures and build features (caching, queues, leaderboards) without touching cluster config.
Best for AI-powered applications (RAG, semantic caching): Because Redis Cloud lets you turn on vector search, JSON, and semantic capabilities inside the same database that powers your cache and sessions—reducing latency and simplifying your stack.

Limitations & Considerations

Network latency: Your app talks to Redis Cloud over the network.
Workaround: Deploy Redis Cloud in the same cloud provider/region (or VPC peering) as your app. For ultra-low latency edge cases, consider Redis Software closer to the workload.
Managed-service boundaries: You don’t control underlying OS or instance-level tuning.
Context: This is usually good—Redis Cloud handles scaling, patching, and failover. For very specialized setups, Redis Software or Redis Open Source gives you deeper control.

Pricing & Plans

Redis Cloud uses a simple, pay-as-you-go model, especially when purchased through AWS Marketplace, where:

You’re billed based on GB-hours of data, so you only pay for what you actually use.
Charges appear directly on your AWS bill, streamlining procurement—no extra invoicing flows.

While exact pricing tiers evolve, plans generally map like this:

Developer / Free Trial: Best for individual developers or small teams needing a low-friction way to prototype caching, sessions, or a small RAG proof of concept.
Production / Enterprise: Best for teams running business-critical workloads that need higher SLAs, 99.999% uptime configurations, features like Active-Active Geo Distribution, and larger capacity with predictable performance.

For the most up-to-date pricing details, go to https://redis.io/ → Redis Cloud → Pricing, or find Redis Cloud on your cloud marketplace of choice.

Connect to your first Redis Cloud database

Once your database is active, the next step is to connect from your application. Redis Cloud works with popular client libraries across Python, Node.js, Java, .NET, Go, PHP, and more.

Below are minimal examples showing how to plug in the Redis Cloud endpoint and password. Replace:

REDIS_HOST with your Redis Cloud host.
REDIS_PORT with your port.
REDIS_PASSWORD with your database password.

Python example (redis-py)

import os
import redis

r = redis.Redis(
    host=os.getenv("REDIS_HOST"),
    port=int(os.getenv("REDIS_PORT", "6379")),
    password=os.getenv("REDIS_PASSWORD"),
    ssl=True,  # Redis Cloud typically uses TLS
)

# Quick sanity check
r.set("hello", "redis-cloud")
print(r.get("hello"))

Node.js example (node-redis)

import 'dotenv/config';
import { createClient } from 'redis';

const client = createClient({
  socket: {
    host: process.env.REDIS_HOST,
    port: Number(process.env.REDIS_PORT || 6379),
    tls: true,
  },
  password: process.env.REDIS_PASSWORD,
});

(async () => {
  await client.connect();
  await client.set('hello', 'redis-cloud');
  const value = await client.get('hello');
  console.log(value);
  await client.quit();
})();

Java example (Jedis)

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisClientConfig;
import redis.clients.jedis.DefaultJedisClientConfig;

public class RedisCloudExample {
    public static void main(String[] args) {
        String host = System.getenv("REDIS_HOST");
        int port = Integer.parseInt(System.getenv("REDIS_PORT"));
        String password = System.getenv("REDIS_PASSWORD");

        JedisClientConfig config = DefaultJedisClientConfig.builder()
                .password(password)
                .ssl(true)
                .build();

        try (Jedis jedis = new Jedis(host, port, config)) {
            jedis.set("hello", "redis-cloud");
            System.out.println(jedis.get("hello"));
        }
    }
}

Note: For production, also configure connection pooling and timeouts in your client, and monitor Redis Cloud metrics (via Redis Insight or Prometheus/Grafana) to watch latency and memory usage.

Frequently Asked Questions

Do I need a credit card to sign up for Redis Cloud?

Short Answer: Often you can start with a free tier or trial without committing to a large plan, but requirements can vary by region and marketplace.

Details: If you sign up directly via redis.io, you may get access to a free trial or dev-sized plan to test Redis Cloud. If you subscribe via AWS Marketplace (or another cloud marketplace), the service uses your existing cloud billing account under a pay-as-you-go model. That means no separate Redis invoice—usage appears on your cloud bill and is charged according to the GB-hours and throughput you consume.

How many databases can I create in a Redis Cloud subscription?

Short Answer: You can typically create multiple databases in a single Redis Cloud subscription, depending on plan limits.

Details: A subscription is a logical container for one or more Redis databases running in a specific cloud and region. Within that subscription, you can create separate databases for:

Caching
Sessions
AI vector search / RAG retrieval
Background queues / streams

Each database gets its own endpoint and configuration (memory, modules, security settings). Plan tier and capacity determine how many databases you can run efficiently in that subscription.

Summary

Signing up for Redis Cloud and creating your first database is a fast way to add a high-performance, fully managed fast memory layer to your stack. You:

Create a Redis Cloud account (directly or via AWS/GCP/Azure marketplace).
Set up a subscription in the region closest to your application.
Create a database with the data types and modules your workload needs (cache, JSON, search, vectors).
Connect from your app using standard Redis client libraries over TLS.

From there, you can grow from simple caching and sessions to real-time queries, vector search, semantic caching, and AI agent memory—all on the same managed Redis platform.

Next Step

Get Started