title: Manage account settings

summary: Describes the settings for a Redis Cloud account.

title: Overview

text:
To review or manage the settings associated with your Redis Cloud account, sign in to the [Redis Cloud console](https://cloud.redis.io/) and then select **Account Settings** from the menu.

This displays the **Account Settings** screen:

The available tabs depend on your account, and may include:

- The **Account** tab displays basic information associated with your account, including general info, address details, time zone setting, security settings, and provider integration details.

- The **Cloud Account** tab is displayed for Redis Cloud Pro subscriptions hosted on Amazon Web Services (AWS).  To learn more, see [Bring your own Cloud]().

- The **Integrations** tab lets you manage certain integrations.

You can change some settings by selecting **Edit**. For help changing other settings, [contact Support](https://redis.io/support/).

title: Redis account info settings

text:
The **Redis Account Info** section provides basic details about your account, including:

| Setting          | Description |
|------------------|-------------|
| _Redis account name_   | Name associated with the Redis Cloud account |
| _Redis account number_ | Internal ID of the Redis account |
| _Date created_   | Date the user's Redis Cloud account was created, which may differ from the organization account creation date |
| _Last updated_   | Date of the last administrative change to the owner's account, typically reflects access changes or other administrative updates |

Select **Edit** to change the Redis Account name.

After changing the account name, use the **Save changes** button to save changes or **Discard changes** to revert them.

You cannot change the email address associated with a Redis Cloud account.  Instead, create a new account with the updated email address, assign it as an administrator to the organization account, and then use the new account to delete the account with the invalid email address.

title: Contacts & Business information

text:
The **Contacts & Business information** section shows the company name and business address associated with the current Redis Cloud account. Redis uses the company name and business address for invoice and tax purposes.

In addition, this section may include fields unique to your location.  For example, certain regions require tax IDs or other regulatory details.

Select **Edit** to change the account's company name and business address.

When you change your business address, you must approve the use of the information in this section for communication and billing purposes before you can save. After approving, select **Save changes** to save your changes or **Discard changes** to revert them.

title: Security settings

role: security

text:
The **Security** section lets you:

- Manage [multi-factor authentication]() (MFA) for your Redis Cloud account.

- Download the [Redis Cloud certificate authority (CA) bundle]() as a [PEM](https://en.wikipedia.org/wiki/Privacy-Enhanced_Mail) file, which contains the certificates associated with your Redis Cloud account.

title: Time zone settings

text:
To change the time zone settings, select **Edit** and then select the desired time zone from the **Time zone** drop-down.

Select **Save changes** to save your changes or **Discard changes** to revert them.

title: Integration settings

text:
The **Integrations** tab includes settings that help you manage integrations of your Redis Cloud account with other services.

For more details, see:
- [Use the Redis Sink Confluent Connector]()
- [Prometheus and Grafana with Redis Cloud]()


title: Manage accounts and settings

summary: Describes how to work with Redis Cloud accounts and manage their settings.

title: Manage account settings

summary: Describes the how to manage your user account profile and how to switch between Redis Cloud accounts.

title: Manage user account and profile

page_type: content

title: Content

role: content

text:
Here, you learn how to manage Redis Cloud accounts and their settings:

- [Manage account settings]()

- [Manage user account and profile]()

- [Switch between Redis Cloud accounts]()


title: Manage user account and profile

title: Overview

role: overview

text:
When you sign in to the [Redis Cloud console](https://cloud.redis.io/), you use a profile associated with one or more Redis Cloud accounts.

This account has a profile with settings that you can manage using the Profile control located near the top, right corner of the Redis Cloud console:

When you open the Profile control, you can:

- Review and manage your user account profile.

- Sign out from the Redis Cloud console.

- Switch between Redis Cloud subscriptions administered by your user account.

title: Manage user profile

text:
To review your user profile settings, select **User profile** from the Profile control.  This displays the **User Profile** screen:

This screen contains up to three sections, including:

- The *User details* section includes basic information about your account, including _First name_, _Last name_, _Job title_, _Email_, and the date the account was created.  The names and job title can be edited; other settings are read-only.

- The *Password* section lets you change the password for accounts created and managed by Redis Cloud.

    If you're using single sign-on authentication, you cannot change the password using the *User Profile* screen.  Such accounts are managed by an identity provider (IdP).  For help changing (or recovering) the passwords for these accounts, consult your identity provider docs.

- The **Multi-factor authentication (MFA)** section lets you [manage MFA settings]() for the current user account.

    When you activate a mobile device, you can use SMS MFA as a second authentication factor.

    To use an authentication app as the factor, you need to activate a mobile device and then use that device to enable the app.

title: Sign out

text: To sign out from the Redis Cloud console, select **Logout** from the profile control.

title: Switch Redis cloud accounts

text:
When your user account is authorized to manage multiple Redis Cloud accounts, each account is displayed in the Profile control.

To switch accounts, select the desired account from the list shown in the Profile control.

To create another Redis Cloud account associated with the same email address, you need to [sign up for Redis Cloud]() again with a plus address of the email address. For many email providers, you can do this by adding `+` and any string to the end of your username. For example, if your address is `example@example.com`, enter `example+account2@example.com`.

title: Save or discard changes

text: Use the **Discard changes** button to cancel user profile setting changes or the **Save changes** button to save changes.


title: Redis Cloud API

page_type: index


title: Audit using System Log

summary: Use the system log to track and audit actions performed in the account.

title: Overview

text:
System logs collect and report actions performed on various entities in your Redis Cloud subscription.  These entities include the account itself, users, API Keys, subscriptions, databases, accounts, payment methods, and more. For each entity, various lifecycle events are logged in the system log.

To view the log, sign in to the [Redis Cloud console](https://cloud.redis.io/) and then select **Logs** from the main menu.

To learn more, see [System logs]().

title: Get system logs via REST API

text:
The REST API operation for querying the system log is [`GET /logs`]().

The `/logs` API operation accepts the following parameters:

- `offset` - The starting point for the results.  The default value of `0` starts with the latest log entry. A value of `11` skips the first 10 entries and retrieves entries starting with the 11 and older.
- `limit` - The maximum number of entries to return per request. The default value is `100`.

The system log reports activity for the entire account. It reports log entries for all types of entities, including subscriptions, databases, and so on.

title: Request results

text:
An API system log request results in data that includes an `entries` array. The entries are sorted by system log entry ID in descending order and include the following properties:

- `id` - A unique identifier for each system log entry.

- `time` - The system log entry timestamp, defined in ISO-8601 date format and in the UTC timezone (for example: `2019-03-15T14:26:02Z`).

- `originator` - The name of the user who performed the action described by the system log entry.

- `apiKeyName` - The name of the API key used to perform the action described by the system log entry.
    This field only appears if the action was performed through the API.
    If the operation was performed through the Redis Cloud console, this property is omitted.

- `resource` - The name of the entity associated with the logged action (for example, database name).
    This property is omitted if it is not applicable to the specific log entry.

- `type` - The category associated with the action log entry.

- `description` - The detailed description of the action in the log entry.


title: Database backup and import

summary: When you create or update a database, you can specify the backup path. The import API operation lets you import data from various source types and specified locations.

title: Back up a database

text:
When you create or update a database, you can specify the (optional) `periodicBackupPath` parameter
with a [backup path]().
This parameter enables periodic and on-demand backup operations for the specified database.

The number of database backups that can run simultaneously on a cluster is limited to 4 by default.

For Redis Cloud Pro databases, back up a database with [`POST /subscriptions/{subscriptionId}/databases/{databaseId}/backup`](). For Redis Cloud Essentials databases, use [`POST /fixed/subscriptions/{subscriptionId}/databases/{databaseId}/backup`]().
On-demand database backup is an [asynchronous operation]().

The backup database API does not require a body. Instead, the `periodicBackupPath` must be set to a valid path with available storage capacity to store the backup files for the specific database. You can set an `adhocBackupPath` in the body to specify a different backup location for this backup.

See [Set up backup storage locations]() to learn how to configure your backup storage locations.

title: Import data to a database

text:
You can import data into an existing database from multiple storage sources, including AWS S3, Redis, and FTP.
Database import is an [asynchronous operation]().

Use [`POST /v1/subscriptions/{subscriptionId}/databases/{databaseId}/import`]() to import data to an existing Redis Cloud Pro database. For Redis Cloud Essentials databases, use [`POST /fixed/subscriptions/{subscriptionId}/databases/{databaseId}/backup`]()

The requirements for data import are:

- The URI of the data
    - The source URI must be accessible to the importing database
    - The data format must be a Redis backup file or a Redis database
- The subscription ID and database ID of the destination database

The duration of the import process depends on the amount of data imported and the network bandwidth between the data source and the importing database.

Data imported into an existing database overwrites any existing data.

You can specify the backup location with the `sourceType` and `importFromUri` values for these sources:

|Data location|`sourceType`|`importFromUri`|
|---|---|---|
|Amazon AWS S3|aws-s3|s3://bucketname/[path/]filename.rdb[.gz]|
|FTP|ftp|ftp://[username][:password]@[:port]/[path/]filename.rdb[.gz]|
|Google Blob Storage|google-blob-storage|gs://bucketname/[path/]filename.rdb[.gz]|
|Microsoft Azure Blob Storage|azure-blob-storage|abs://:storage_account_access_key@storage_account_name/[container/]filename.rdb[.gz]|
|Redis server|redis|redis://[db_password]@[host]:[port]|
|Web server|HTTP|HTTP://[username][:password]@[:port]/[path/]filename.rdb[.gz]|

See [Import data]() to learn how to set up your storage locations for data import.


title: Create and manage databases

summary: This article describes how to create and manage a database using the Redis Cloud API.

title: Overview

text: You can use the Redis Cloud REST API to create and manage databases.

title: Redis Cloud Essentials

title: Create an Essentials database

text:
To create a Redis Cloud Essentials database, use [`POST /fixed/subscriptions/{subscriptionId}/databases`]().

This call creates a database in the specified subscription. Use [`GET /fixed/subscriptions`]() to get a list of Essentials subscriptions and their IDs.

[code example]

This example JSON body contains only the most basic, required parameters to create a database:

- `name`: The database name. A unique name per subscription that can contain only alphanumeric characters and hyphens

There are other additional parameters and settings that can be defined on database creation. Review the database parameters and options in the [full API reference]().

Some options may not be compatible with your selected plan. Use [`GET /fixed/subscriptions/{subscriptionId}`]() to view the plan you have selected and what options it supports.

The response body contains the `taskId` for the task that creates the database. You can use [`GET /v1/tasks/{taskId}`]() to track the task's status.

title: Update an Essentials database

text:
To update a Redis Cloud Essentials database, use [`PUT /fixed/subscriptions/{subscriptionId}/databases/{databaseId}`]().

The primary component of a database update request is the JSON request body that contains the details of the requested database changes. You can see the full set of changes you can make in the [full API reference]().

Some options may not be compatible with your selected plan. Use [`GET /fixed/subscriptions/{subscriptionId}`]() to view the plan you have selected and what options it supports.

The response body contains the `taskId` for the task that updates the database. You can use [`GET /v1/tasks/{taskId}`]() to track the task's status.

title: Redis Cloud Pro

title: Create a Pro database

text:
If you want to create a Pro database in a new subscription, see [Create a Pro subscription]().

To create a Redis Cloud Pro database in an existing subscription, use [`POST /subscriptions/{subscriptionId}/databases`]().

This call creates a database in the specified subscription. Use [`GET /subscriptions`]() to get a list of subscriptions and their IDs.

[code example]

This example JSON body contains only the most basic, required parameters to create a database:

- `name`: The database name. A unique name per subscription that can contain only alphanumeric characters and hyphens
- `datasetSizeInGb`: Maximum dataset size in GB

There are many additional parameters and settings that can be defined on database creation. Review the database parameters and options in the [full API reference]().

The response body contains the `taskId` for the task that creates the database. You can use [`GET /v1/tasks/{taskId}`]() to track the task's status.

title: Update a Redis Cloud Pro database

text:
To update a Redis Cloud Pro database, use [`PUT /subscriptions/{subscriptionId}/databases/{databaseId}`]().

The primary component of a database update request is the JSON request body that contains the details of the requested database changes. You can see the full set of changes you can make in the [full API reference]().

The response body contains the `taskId` for the task that updates the database. You can use [`GET /v1/tasks/{taskId}`]() to track the task's status.

code:
POST "https://[host]/v1/fixed/subscriptions/{subscriptionId}/databases"
{
  "name": "Basic-essentials-database-example"
}

section_id: create-an-essentials-database

code:
POST "https://[host]/v1/subscriptions/{subscriptionId}/databases"
{
  "name": "Basic-database-example",
  "datasetSizeInGb": 1
}

section_id: create-a-pro-database


title: Estimate cost

summary: How to evaluate the cost of a specific subscription or database without changing existing resources.

title: Overview

text:
When you change your subscriptions and databases, you also change the cost of your deployment.
With a **dry-run request**, you can evaluate the impact and obtain a new cost estimate before you deploy these changes:

- Create subscription
- Create a database
- Update a database

title: Defining a dry-run request

text:
API operations that support dry-run requests accept the `dryRun` boolean parameter in the JSON request body.

For example, the JSON body of a create subscription request body can include `"dryRun": true`:

[code example]

title: Executing a dry-run request

text:
Dry-run requests behave like regular requests except that no changes are made to existing resources.
A dry-run request produces a cost evaluation report for the subscription.

| API Operation | `"dryRun": false` (default) | `"dryRun": true` |
|---|---|---|
| **Create subscription** | Create a subscription | Returns a cost evaluation report of the planned subscription |
| **Create database** | Creates a new database in the subscription | Returns a cost evaluation report for the relevant subscription |
| **Update database** | Changes the specified database | Returns a cost evaluation report and evaluates whether the relevant subscription requires additional resources based on the database modification |

title: Example of a dry-run request & response

role: example

text:
This section demonstrates a complete example of a create subscription dry-run request and response.

#### Dry-run request body

Here is an example of the pricing request body:

[code example]

1. The create subscription request contains the `"dryRun": true` parameter
2. The databases array contains the definitions of multiple database templates, named `database-a`,  `database-b`, `database-c`, etc.
3. Note that the databases differ in structure (size, throughput measurement, replication, quantity, etc.)

#### Dry-run response

Here is an example of the pricing response section for the above create subscription dry-run request:

[code example]

Some of the response content was omitted for brevity.

1. The `pricing` array contains an element for each database, containing the database name and cost evaluation related to that database
2. The database cost is measured in type and number of shards required for the specific database, as defined by the database template in the request. See [Cloud Pricing](https://redislabs.com/redis-enterprise-cloud/pricing)
3. The cost evaluation for each database is measured in quantity of the specific shard type required by the requested database. The cost per shard is defined by the fields `pricePerUnit` (where `unit` is a shard of the specific type), `priceCurrency`, and `pricePeriod`
4. For example, to calculate the total hourly cost of a database, use the following formula:  `pricePerUnit` * `quantity`
5. The structure of the pricing response depends on the cloud account used by the request. There are two types of cloud accounts: a cloud account owned, named, and managed by the customer (AWS only) and one maintained by "Redis resources" cloud account (All cloud providers)
6. For a customer-provided cloud account - The cost evaluation response lists the AWS resources required (storage and compute instances) without pricing data (which depends on the specific details of the customer's AWS account)
7. For a Redis internal cloud account (defined a `cloudAccountId = 1` in the create subscription request) - The cost evaluation response includes a `MinimumPrice` element. This indicates the minimal hourly cost of the entire subscription. This minimum price will be charged if the sum of all shards for all the subscription's databases is less than the specified minimum price

title: Viewing actual subscription cost

text: The `Get subscriptions` and `Get subscription by id` JSON response contains an element named `subscriptionPricing` that details the latest calculated cost of a subscription, grouped by shard type for all the databases in the subscription.

section_id: defining-a-dry-run-request

DryRun Cost evaluation subscription

database-a

by: operations-per-second

section_id: example-of-a-dry-run-request-response


title: Generate FOCUS-compliant cost report

summary: Shows how to generate and download a cost report in FOCUS format using the Redis Cloud REST API.

title: Overview

text:
You can use the Redis Cloud REST API to generate and download a cost report in a [FinOps Open Cost and Usage Specification (FOCUS)](https://focus.finops.org/) compatible format. The report includes detailed information about your Redis Cloud subscription usage and associated charges.

The following sections provide examples for each step.

title: Generate a cost report

text:
To generate a cost report, use [`POST /cost-report`](). Your account must have the **Owner** or **Viewer** role to generate a cost report through this endpoint.

Include `startDate` and `endDate` in your request body using `YYYY-MM-DD` format. You can specify a date range up to 40 days.

[code example]

More options and filters can be added to the request body to filter the report data.

| Option name | Type | Description |
|-------------|--------|-------------|
| `format` | Enum: `csv`, `json` | The format for the report file. Default is `csv`. |
| `subscriptionIds` | Array of integers | Filters the report to only include the specified subscriptions. |
| `databaseIds` | Array of integers | Filters the report to only include the specified databases. |
| `subscriptionType` | Enum: `essentials`, `pro` | Filters the report to only include subscriptions of the specified type. |
| `regions` | Array of strings | Filters the report to only include subscriptions in the specified regions. |
| `tags` | Array of key-value pairs | Filters the report to only include databases with the specified [tags](). Both `key` and `value` are required for each tag. |

For example, the following request body generates a CSV report for all databases in the `us-east-1` region that have the `team:marketing` tag in January 2025:

[code example]

The response body is a [task object]() that contains the `taskId` for the task that generates the cost report:

[code example]

title: Get cost report status

text:
To get the status of the cost report generation, use [`GET /tasks/{taskId}`]() with the `taskId` from the previous step.

When the report is ready, the `status` is `processing-completed` and the `response` field contains a `costReportId`:

[code example]

title: Download cost report

text:
To get the cost report, use [`GET /cost-report/{costReportId}`]() with the `costReportId` from the previous step.

You can use this cost report with any FOCUS-compatible cost reporting tool to analyze and visualize your costs.

title: Cost report fields

text:
The cost report returned from the Redis Cloud REST API contains fields from the [FOCUS column library](https://focus.finops.org/focus-columns/). The Redis Cloud-specific implementation is described in the following sections.

#### Billing account and publisher fields

| Field | Type | Description |
|---|---|---|
| `BillingAccountId` | String | Redis Cloud account ID. |
| `BillingAccountName` | String | Display name of the Redis Cloud account. |
| `BillingAccountType` | String | Type of billing account structure. Always set to `Redis Cloud`. |
| `PublisherName` | String | Publisher/vendor of the service, which is Redis. Always `redis.io`. |

#### Pricing fields

| Field | Type | Description |
|---|---|---|
| `PricingCategory` | String | Pricing model category. Always `Standard`. |
| `PricingCurrency` | String | The currency used for pricing. Always `USD`. |
| `PricingQuantity` | BigDecimal | Quantity of units being priced. For hourly services like Redis Cloud Pro, this is the number of hours. For monthly services like Redis Cloud Essentials and network costs, this is typically one month. |
| `PricingUnit` | String | The unit of measure for pricing. Can be `Hours` (Pro), `Months` (Essentials), or `Network`. |

#### Period fields

| Field | Type | Description |
|---|---|---|
| `BillingPeriodStart` | Instant (ISO 8601 DateTime) | Start of the billing period (inclusive). |
| `BillingPeriodEnd` | Instant (ISO 8601 DateTime) | End of the billing period (exclusive). |
| `ChargePeriodStart` | Instant (ISO 8601 DateTime) | Start of the specific charge period (inclusive). May differ from billing period if the resource was created mid-period. |
| `ChargePeriodEnd` | Instant (ISO 8601 DateTime) | End of the specific charge period (exclusive). May differ from billing period if the resource was deleted mid-period. |

#### Cost fields

| Field | Type | Description |
|---|---|---|
| `BilledCost` | BigDecimal | Cost that Redis will invoice you for. |
| `BillingCurrency` | String (ISO 4217) | Currency code for all billing amounts. Always `USD`. |
| `ConsumedQuantity` | BigDecimal | Actual amount of resources used. May be null for fixed-price plans. |
| `ConsumedUnit` | String | Unit for `ConsumedQuantity`. Can be `Hours` or `Network`. |
| `ContractedCost` | BigDecimal | Cost after applying contractual discounts but before credits. |
| `ContractedUnitPrice` | BigDecimal | Per-unit price after applying your negotiated discounts. |
| `EffectiveCost` | BigDecimal | True cost after all discounts, credits, and adjustments. |
| `ListCost` | BigDecimal | Cost at Redis's published list prices before any discounts. |
| `ListUnitPrice` | BigDecimal | Redis's published price per unit at list rates. |

#### Location, Resource, and SKU fields

| Field | Type | Description |
|---|---|---|
| `RegionId` | String | Cloud vendor region identifier. |
| `RegionName` | String | Display name of the region. |
| `ResourceId` | String | Identifier of the resource being charged. |
| `ResourceName` | String | Display name you gave to the resource in the Redis Cloud console. |
| `ResourceType` | String | Whether the charge is for a specific database or a subscription-level service. |
| `Tags` | JSON Map<String, String> | User-defined tags on resources. |
| `SkuPriceDetails` | JSON Map<String, Object> | Redis-specific technical details about the database configuration, such as RBUs, memory limit, and throughput. |

#### Charge fields

| Field | Type | Description |
|---|---|---|
| `ChargeCategory` | String | Category of the charge: `Usage`, `Purchase`, `Tax`, or `Adjustment`. |
| `ChargeDescription` | String | A clear description of what you're being charged for, combining service type and resource details. |
| `ChargeFrequency` | String | How often the charge occurs - always `Recurring`. |

#### Service fields

| Field | Type | Description |
|---|---|---|
| `ServiceCategory` | String | The high-level category of service - always `Databases`. |
| `ServiceName` | String | The Redis Cloud service tier - `Redis Cloud Pro` or `Redis Cloud Essentials`. |
| `ServiceSubcategory` | String | The specific type of database service - always `Caching`. |

section_id: generate-a-cost-report

format: csv

key: team

value: marketing

commandType: costReportCreateRequest

status: received

description: Task request received and is being queued for processing.

type: GET

rel: task

status: processing-completed

description: Request processing completed successfully and its resources are now being provisioned / de-provisioned.

rel: self

section_id: get-cost-report-status


title: REST API Examples

summary: These examples show how to use the API and the results to expect.

summary: Describes how to create and manage a subscription using the Redis Cloud API.

title: Create and manage subscriptions

title: Create and manage databases

title: Database backup and import

title: Estimate cost

title: Audit using System Log

title: Generate FOCUS-compliant cost report


title: Create and manage subscriptions

title: Overview

text: The Redis Cloud REST API lets you create and manage all kinds of subscriptions.

title: Redis Cloud Essentials

title: Create an Essentials subscription

text:
Use [`POST /v1/fixed/subscriptions`]() to create an Essentials subscription.

[code example]

Modify the following parameters in the sample JSON document to create a subscription on your own account:

- **`paymentMethodId`** - Specify a payment method connected to your account.

    Use [`GET /v1/payment-methods`]() to find a payment method ID.

    You don't need to pass this field in your API request if you subscribed to Redis Cloud through a marketplace integration.

- **`planId`** - Specify an essentials plan to create.

    Use [`GET /v1/fixed/plans`]() to get a list of plan IDs.

After you create an Essentials subscription, you must use the [`POST /v1/fixed/subscriptions/{subscriptionId}/databases`]() endpoint to [create the database]().

You can include the contents of the JSON document in the `POST /v1/fixed/subscriptions` operation in the [Swagger UI](https://api.redislabs.com/v1/swagger-ui.html). See [Swagger user interface]() for more details.

The Swagger UI generates default JSON examples for `POST` and `PUT` operations. You can reference these examples and modify them to fit your specific needs and account settings. The examples will fail if used as-is.

The response body contains the `taskId` for the task that creates the subscription. You can use [`GET /v1/tasks/{taskId}`]() to track the task's status.

title: Update an Essentials subscription

text:
Use [`PUT /v1/fixed/subscriptions/{subscriptionId}`]() to update an Essentials subscription.

[code example]

You can only change the following settings with this endpoint:
- **`name`** - Specify a new name for your subscription.

- **`planId`** - Specify a new Essentials plan to change to.

    You can only change to a plan that:

    - Is in the same cloud provider and region of your current plan.

    - Has a compatible [High-availability option]() to your current plan. For example, if your current plan has single-zone replication, you cannot switch to a plan with multi-zone replication, but you can switch to a plan with no replication. If your current plan has multi-zone replication, you must switch to a plan with multi-zone replication.

    Use [`GET /v1/fixed/plans/subscriptions/{subscriptionID}`]() to get a list of plan IDs that are compatible with your subscription.

- **`paymentMethodId`** - Specify a different payment method connected to your account.

    Use [`GET /v1/payment-methods`]() to find a payment method ID.

The response body contains the `taskId` for the task that updates the subscription. You can use [`GET /v1/tasks/{taskId}`]() to track the task's status.

title: Delete an Essentials subscription

text:
Use [`DELETE /v1/fixed/subscriptions/{subscriptionId}`]() to delete a subscription.

[code example]
The response body contains the `taskId` for the task that deletes the subscription. You can use [`GET /v1/tasks/{taskId}`]() to track the task's status.

title: Redis Cloud Pro

title: Create a Pro subscription

text:
Use [`POST /v1/subscriptions`]() to create a Pro subscription.

[code example]

Modify the following parameters in the sample JSON document to create a subscription on your own account:

- **`paymentMethodId`** - Specify a payment method connected to your account.

    Use [`GET /v1/payment-methods`]() to find a payment method ID.

    You don't need to pass this field in your API request if you subscribed to Redis Cloud through a marketplace integration.

The request JSON body contains two primary segments: subscription specification and databases specification. When you create a subscription, you must specify one or more databases in the "`databases`" array.

There are many additional parameters and settings that can be defined on subscription and database creation. Review the subscription parameters and options in the [Full API documentation]().

The response body contains the `taskId` for the task that creates the subscription. You can use [`GET /v1/tasks/{taskId}`]() to track the task's status.

title: Update a Pro subscription

text:
Use [`PUT /v1/subscriptions/{subscriptionId}`]() to update a Pro subscription.

[code example]

You can only change the following settings with this endpoint:
- **`name`** - Specify a new name for your subscription.

- **`paymentMethodId`** - Specify a different payment method connected to your account.

    Use [`GET /v1/payment-methods`]() to find a payment method ID.

The response body contains the `taskId` for the task that updates the subscription. You can use [`GET /v1/tasks/{taskId}`]() to track the task's status.

title: Delete a Pro subscription

text:
Use [`DELETE /v1/subscriptions/{subscriptionId}`]() to delete a subscription.

[code example]
The response body contains the `taskId` for the task that deletes the subscription. You can use [`GET /v1/tasks/{taskId}`]() to track the task's status.

code:
POST "https://[host]/v1/fixed/subscriptions"
{
    "name": "My new subscription",
    "planId": <plan_id>,
    "paymentMethodId": <payment_id>
}

section_id: create-an-essentials-subscription

code:
PUT "https://[host]/v1/fixed/subscriptions/{subscriptionId}"
{
    "name": "new-subscription-name",
    "planId": <plan_id>,
    "paymentMethodId": <payment_id>
}

section_id: update-an-essentials-subscription

section_id: delete-an-essentials-subscription

code:
POST "https://[host]/v1/subscriptions"
{
    "name": "Basic Subscription Example",
    "paymentMethodId": <payment_id>,
    "cloudProviders": [
        {
            "provider": "AWS",
            "regions": [
                {
                    "region": "us-east-1",
                    "networking": {
                        "deploymentCIDR": "10.0.1.0/24"
                    }
                }
            ]
        }
    ],
    "databases": [
        {
            "name": "Redis-database-example",
            "protocol": "redis",
            "datasetSizeInGb": 1
        }
    ]
}

section_id: create-a-pro-subscription

code:
PUT "https://[host]/v1/subscriptions/{subscriptionId}"
{
    "name": "new-subscription-name",
    "paymentMethodId": <payment_id>
}

section_id: update-a-pro-subscription

section_id: delete-a-pro-subscription


title: Enable the API

summary: Use the Redis Cloud dashboard to enable the REST API.

title: Content

text:
If you have a Redis Cloud account, you can use a REST API to manage your subscriptions and databases programmatically.

For security reasons, the Redis Cloud API is inactive by default.

To enable the API:

1. Sign in to your [Redis Cloud account](https://cloud.redis.io) as an account owner.
1. From the menu, choose **Access Management**.
1. When the **Access Management** screen appears, select the **API Keys** tab.

1. If a **Copy** button appears to the right of the API account key, the API is enabled.  This button copies the account key to the Clipboard.

    If you see an **Enable API** button, select it to enable the API and generate your API account key.

To authenticate REST API calls, you need to use both the API account key and an [API user key]() to make API calls.

Only account owners can see the access key in the account settings and give API access to other users.

Make sure that you keep your access keys secret. Anyone who sends an API request with a valid access key can make changes to your account.

To manage your API keys or to limit IP addresses for user keys, see [Manage API keys]().


title: Get started with the REST API

summary: Describes how Redis Cloud REST API uses keys to authenticate and authorize access.

title: Enable the API

summary: How to use the Redis Cloud console to create and manage API user keys for your account's team owners

title: Manage API keys

summary: How to use the API with various tools (especially `cURL`)

title: Use the REST API

summary: A task is an API operation that is performed asynchronously because it exceeds the time allowed for the synchronous request/response model.

title: Manage API tasks

summary: API requests follow specific lifecycle phases and states, based on the complexity and length of execution of the operation.

title: The API request lifecycle

title: Overview

text:
To use the Redis Cloud REST API, you need to:

- Enable the API
- Create an account key
- Create a user key
- Collect endpoint details

To use the keys to authenticate and authorize your request, include the keys with the request headers:

| Key name         | HTTP header name   |Description                                            |
| -----------      | -------------------| ----------------------------------------------------- |
| Account key | `x-api-key`        | Account-level key assigned to all users of an account |
| User key       | <nobr>`x-api-secret-key`</nobr> | Personal key associated with a specific user and possibly limited to certain IP ranges                      |

title: Enable the API

text: The API is disabled on all accounts by default. You must [enable the API]() before you can use it.

title: Account key

text:
The account key identifies your specific account when you perform an API request.  This is the account responsible for your subscription.

An account key is an account-level secret. Do not share this key with anyone not authorized to use the account.

You create the account key once when enabling API access.

If you need to change or delete your account key, please [contact support](https://redislabs.com/company/support/).

title: User key

text:
The user key is a personal key that belongs to a specific user having the **Owner**, **Viewer**, or **Logs viewer** role.  User keys are assigned to users when they're created.  Keys can belong to only one user; however, a user may have multiple keys.

You can view keys or copy their values _only_ during the [creation process]().

User keys are personal secrets. Do not share them.

Individual owners can [generate multiple user keys]()
for themselves, for separate apps, or for other owners, viewers, or log viewers within the same account.

Use key names to uniquely associate specific API requests to individual users or apps.

Doing so lets you [audit API requests]() using the system log, which tracks the key used to authenticate each request.

title: Authentication using API keys

text:
Every API request must use the **account key** and a **user key** to authenticate.

The keys are provided as [HTTP request headers](), shown earlier.

title: Authenticate a request

text:
An API request successfully authenticates when:

1. The account and user keys are valid and properly defined in the HTTP request headers.
1. The user key is associated with the same account as the account key.
1. The request originates from a valid source IP address, as defined in a [CIDR](https://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing) allow list associated with the user key.

    This requirement applies when you've [defined a CIDR allow list]() for the secret key.

title: More info

text:
To learn more, see:

- [Manage API keys]()
- [Use the API]()
- [Full API reference]()


title: Manage API keys

title: Overview

text:
Every REST API request must include the following API keys:

1. The **Account key** identifies the account associated with the Redis Cloud subscription.

2. The **User key** identifies the user and (optionally) the context of a request.  Generated by account owners.

Use the **API Keys** tab of the **Access Management** screen to manage your keys:

1. Sign in to your [Redis Cloud account](https://cloud.redis.io) as an account owner.

1. From the menu, choose **Access Management** and then select the **API Keys** tab.

If an **Enable API** button appears, select it to [enable the REST API]() for your account.

title: API account key

text:
The **API account key** is used as the value of the `x-api-key` HTTP header in order to authenticate a REST API request.

By default, the **API account key** is masked; that is, it is obscured for security reasons.  You can use the **Show** button to display the key and the **Hide** button to mask it.

The **Copy** button copies the account key to the Clipboard.

title: API user keys

text:
**API user keys** (also known as _secret keys_) are used as the value of the `x-api-secret-key` HTTP header used to authenticate a REST API request.

In this context, _user_ refers to the account used to sign in to the Redis Cloud console.  Users must have an owner (read-write) or viewer (read-only) role.

Users can have more than one user key; however, users should not share user keys.

title: Create a new user key {#secret}

text:
Use the **Add** button to create a new user key.

When you do this, you're prompted for the **Key name** and the associated **User name**.

The key name:

- Must be between 10 and 50 characters long
- Can contain alphanumeric characters, hyphens, and underscores. Spaces are not allowed.

The selected user must have an owner, viewer, or logs viewer role.

Select **Create** to create the new key.

When you do this, the **API user key** dialog appears.

This is the only time the value of the user key is available.  Save it to a secure location before closing the dialog box.

If you lose the user key value, it cannot be retrieved.  If this happens, create a new key to replace the lost one.

The **Finish** button is inactive until you copy the key to the clipboard. After you save the user key, you can also select **Copy account key** to save the account key.

title: Delete a user key

text:
To delete a user key:

1.  Use the **API Keys** tab of the **Access Management** screen to locate the target key. Hover over the key to display the **Delete** button.

2.  Select the **Delete** button.

3.  This displays the **Delete API secret key** dialog box.

    Select the **Delete** button to confirm.

title: Manage CIDR allow list

text:
By default, REST API requests are allowed from all IP addresses.  To limit access to specific addresses, define a CIDR allow list for the user key.

To manage the CIDR allow list:

1.  Use the **API Keys** tab of the **Access Management** screen to locate the target key. Hover over the key to display the **Manage** link.

2.  Select the **Manage** link in the **CIDR allow list** column; this displays the **Manage CIDR allow list** dialog box.

3.  Enter each allowed IP address in [CIDR format](https://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing#CIDR_notation) (example: `127.1.0.0/24`) and then select the **Save** button.

    Use the **Add CIDR rule** button to add additional addresses to the list.

    Use the **Edit** button to change the address for a rule or the **Delete button** to remove a rule.


title: Manage API tasks

title: Overview

text:
Examples of API operations that use tasks are:

- create subscription
- create database
- update database
- delete database

All create, update, and delete API operations (`POST`, `PUT`, and `DELETE`) and some query operations (`GET`) use tasks.

After you request an asynchronous operation, the operation returns a `taskId` that identities the specific task, and contains contextual and status data on the API operation performed by the task.

Tasks are part of the API [processing and provisioning lifecycle]().

title: Task information

text:
When you request an asynchronous operation, the response to the request includes the task status and additional information about the task:

[code example]

Where:

- `taskId` - The unique identifier (UUID) of the specific task
- `commandType` - The request (command) type
- `status` - The [status]() of the task
- `description` - A description of the status
- `timestamp` - The time of the response in ISO-8601 date format and in the UTC timezone
- `_links` - URI links to resources related to the task including:
    - A link to itself
    - Additional links based on the context of the response

title: Task status updates

text:
With the task ID, you can query the task status for updates and progress information.
The response in the above example shows a URL with the title `getTaskStatusUpdates`.
The URL in the `href` property returns updates for the specified task.

Use [`GET /v1/tasks/{taskId}`]() to check the task status.

This endpoint returns information about the queried task.

[code example]

This response example shows:

- The `status` value is `"processing-completed"`.
- The `response` field contains the resource identifier of the subscription resource changed by this task.
- The `links` array contains another `getSubscriptionInformation` URL that links to the newly created subscription.
    This link queries the subscription status during [provisioning]())

title: Tasks list

text:
You can use the API operation [`GET /tasks`]() to list the recently submitted and completed tasks for the current account.

This API operation returns a list of tasks for the current account, sorted by most recent status update.

The result returns all the tasks submitted during the past 10 days.

commandType: subscriptionCreateRequest

title: getTaskStatusUpdates

section_id: task-information

description: Request processing completed successfully and its resources are now being provisioned / de-provisioned.

title: getSubscriptionInformation

section_id: task-status-updates


title: The API request lifecycle

title: Overview

text:
Redis Cloud owners and viewers can leverage a REST API that permits operations against a variety of resources, including subscriptions, databases, and related infrastructure.

[Once it's enabled](), you can use the REST API to create, update, and delete subscriptions, databases, and other entities.

All create, update, and delete API operations (`POST`, `PUT`, and `DELETE`) and some query operations (`GET`) run asynchronously, which means that provisioning or processing occurs in the background.  When you submit a request, a background process, known as a **Task**, starts working on it.  The response object includes an ID that lets you determine the status of the background process as it works.

For operations that do not create or modify resources or do not require additional processing (such as most GET operations), the API is synchronous; that is, the response object reports the results of the request.

Asynchronous operations have two main phases: processing and provisioning.  A resource is not available until both phases are complete.

title: Task processing

text: During this phase, the request is received, evaluated, planned, and executed.

title: Use tasks to track requests

text:
The response objects for all asynchronous operations provide a `taskId` identifier that lets you track the progress of the underlying operation.

You can query the `taskId` to track the state of a specific task using [`GET /v1/tasks/{taskId}`]().

You can also query the state of all active tasks or recently completed tasks in your account using [`GET /tasks`]().

title: Task process states

text:
During the processing of a request, the task moves through these states:

- `received` - Request is received and awaits processing.
- `processing-in-progress` - A dedicated worker is processing the request.
- `processing-completed` - Request processing succeeded and the request is being provisioned (or de-provisioned, depending on the specific request).
    A `response` segment is included with the task status JSON response.
    The response includes a `resourceId` for each resource that the request creates, such as Subscription or Database ID.
- `processing-error` - Request processing failed.
    A detailed cause or reason is included in the task status JSON response.

A task that reaches the `received` state cannot be cancelled and it will await completion (i.e. processing and provisioning). If you wish to undo an operation that was performed by a task, perform a compensating action (for example: delete a subscription that was created unintentionally)

title: Task provisioning phase

text:
When the processing phase succeeds and the task is in the `processing-completed` state, the provisioning phase starts.
During the provisioning phase, the API orchestrates all of the infrastructure, resources, and dependencies required by the request.

The term "provisioning" refers to all infrastructure changes required in order to apply the request. This includes provisioning new or additional infrastructure.

The provisioning phase may require several minutes to complete. You can query the resource identifier to track the progress of the provisioning phase.

For example, when you provision a new subscription, use [`GET /v1/subscriptions/{subscriptionId}`](), where the `{subscriptionId}` is the resource ID that you receive when the task is in the `processing-completed` state.

title: Provisioning state values

text:
During the provisioning of a resource (such as a subscription, database, or cloud account) the resource transitions through these states:

- `pending` - Provisioning is in progress.
- `active` - Provisioning completed successfully.
- `deleting` - De-provisioning and deletion is in progress.
- `error` - An error occurred during the provisioning phase, including the details of the error.

title: Process limitations

text:
The following limitations apply to asynchronous operations:

- For each account, only one operation is **processed** concurrently. When multiple tasks are sent for the same account, they will be received and processed one after the other.
- The provisioning phase can be performed in parallel except:
    - Subscription creation, update, and deletion: You cannot change (make non-active) more than three subscriptions at the same time.
    - Database creation in an existing subscription: This can cause the subscription state to change from `active` to `pending`
    during  database provisioning in cases such as database sizing that requires cluster resizing or updating cluster metadata.

- For example:
    - Concurrently sending multiple "create database" tasks will cause each task to be in the `received` state, awaiting processing.
    - When the first task starts processing it will be moved to the `processing-in-progress` state.
    - When that first task is completed (either `processing-completed` or `processing-error`), the second task will start processing, and so on.
    - Typically, the processing phase is much faster than the provisioning phase, and multiple tasks will be in provisioned concurrently.
    - If the creation of the database requires an update to the subscription, the subscription state is set to `pending`.
    When you create multiple databases one after the other, we recommend that you check the subscription state after the processing phase of each database create request.
    If the subscription is in `pending` state you must wait for the subscription changes to complete and the subscription state to return to `active`.


title: Use the REST API

title: Overview

text:
You can access and use the API endpoint URI ([`https://api.redislabs.com/v1`](https://api.redislabs.com/v1/)) with any of the following tools:
- The Swagger user interface
- The cURL HTTP client
- An HTTP client in any programming language

For the Redis Cloud API, there is a request limit of 400 requests per minute per Account API key. If you go past this limit, your API requests will fail.

title: Swagger user interface

text: The [Swagger UI](https://api.redislabs.com/v1/swagger-ui.html) is useful for initial introduction and for learning about API operations, models, and simulated usage.

title: Authenticate to Swagger

text:
To authenticate to the Swagger UI:

1. Open the [Swagger UI](https://api.redislabs.com/v1/swagger-ui.html) page in a browser.

1. Select `Authorize`.

    The **Available Authorizations** box is shown with the headers and values that are used for authentication in all API interactions with Swagger.

1. Insert the API Key values:

    1. Enter the [Account Key]() as the `x-api-key` value and then choose **Authorize**.
    1. Enter the [Secret Key]() as the `x-api-secret-key` value and then choose **Authorize**.
    1. Select **Close**.

The key values are not saved when you refresh the page.

When authorization is successful, the lock icon displays a closed lock.

title: Make API requests

text:
After you complete the authorization in the Swagger UI, you can make an API request:

1. Open an action category and select an API operation.

    For example, in the `Account` category select the `GET /payment-methods` operation.

1. Select **Try it out** and then select **Execute**.

    The API response is shown in the **Responses** section of the API operation.
    The results include an example of how to execute the same operation in a standard command-line utility using `cURL`.

#### Inputs for operations in Swagger

Some API operations require input, such as:

- **Parameters** - When an API operation requires URI parameters, such as "get subscription by subscription id", you can enter the values for the parameters.

- **JSON Request Body** - For API operations that require a JSON request body, you can either:

    - Use the **model display** to write the request based on the expected JSON structure and parameters.

    - Use the **Try it now** sample JSON created by Swagger as a base template that you can edit and execute.

The Swagger UI generates default JSON examples for `POST` and `PUT` operations. You should modify these examples to suit your specific needs and account settings. The examples will fail if used as-is.

For more examples showing how to use specific endpoints, see [REST API examples]().

title: Use the `cURL` HTTP client

text:
`cURL` is a popular command line tool used to perform HTTP requests,
either as individual commands or within shell scripts (such as bash and zsh).
For an introduction, see [How to start using cURL and why: a hands-on introduction](https://www.freecodecamp.org/news/how-to-start-using-curl-and-why-a-hands-on-introduction-ea1c913caaaa/).

Our examples use `cURL` and Linux shell scripts to demonstrate the API; you can use any standard REST client or library.

Our examples also use `jq`, [a JSON parser](https://stedolan.github.io/jq/).  Use your package manager to install it  (Example: `sudo apt install jq`)

For example, a standard API call to get System Log information looks like this in `cURL`:

[code example]

- The example expects several variables to be set in the Linux shell:

    - **$HOST** - The URI of the REST API host (`api.redislabs.com/v1`)
    - **$ACCOUNT_KEY** - The [account key value]()
    - **$SECRET_KEY** - The personal [secret key value]()

- The line "`| jq -r .`" means that the HTTP response will be piped (forwarded) to the `jq` JSON parser, and it will display only the raw output ("`-r`") of the root element ("`.`")
- You can set the variables using shell commands like the following:

[code example]

code:
curl -s -X GET "https://$HOST/logs" \
    -H "accept: application/json" \
    -H "x-api-key: $ACCOUNT_KEY" \
    -H "x-api-secret-key: $SECRET_KEY" \
    | jq -r .

section_id: use-the-curl-http-client


title: Redis Cloud REST API

summary: Describes the Redis Cloud REST API and links to additional info

title: Get started with the REST API

title: REST API Examples

title: Redis Cloud API

title: Overview

text:
The [Redis Cloud REST API]() helps you manage your Redis Cloud databases programmatically.

You can use the API to:

- Create or manage databases
- Define or change hosting credentials
- Audit access via logs
- Backup or import databases

title: Get started

text:
1. [Enable the API]()
1. [Authenticate and authorize]()
1. [Create API keys]()
1. [Use the API]()
1. [Learn the API lifecycle]()
1. [Create and manage subscriptions]()

title: Examples

text:
1. [Manage subscriptions]()
1. Database examples
    - [Create and manage databases]()
    - [Back up and import data]()
1. [Estimate costs]()

title: More info

text:
- Use the [Redis Cloud API]()
- [Full API Reference]()
- Secure [authentication and authorization]()


title: Download and analyze cost report

summary: Learn how to download and use the cost report for your Redis Cloud account.

title: Overview

text:
The Redis Cloud cost report gives you a detailed breakdown of your Redis Cloud subscription usage and associated charges. You can use it to track, audit, and optimize your Redis Cloud spending across Essentials and Pro subscription plans.

You can download the cost report from the [**Billing and payments**]() and [**Usage reports**]() pages. You can also use the [Redis Cloud REST API](#rest-api) to get a cost report in [FOCUS](https://focus.finops.org/) format.

The cost report helps you with:

-   Internal cost visibility
-   Usage trend analysis
-   Budget forecasting
-   Troubleshooting unexpected charges

Consider the following limitations when you view the cost report:

-   All pricing is based on list price. Account-specific discounts don't appear in the cost report.
-   Network costs for Pro subscriptions aren't available in the cost report before November 2025.
-   Network costs for Pro subscriptions appear for each subscription. Network costs for individual databases aren't available.
-   Monthly network costs for Pro subscriptions take up to 72 hours to appear in the cost report.

title: Structure

text:
The cost report CSV file has two sections: one for Redis Cloud Essentials subscriptions and one for Redis Cloud Pro subscriptions.

For more information about how to use the cost report effectively, see [How to download and visualize the cost report](https://support.redislabs.com/hc/en-us/articles/30042563097874-How-to-Download-and-Visualize-Redis-Cloud-Cost-Report) in the Redis knowledge base.

title: Essentials subscriptions

text:
In the Essentials subscription section, each row represents one month of usage for a subscription.

| Column | Description |
|:-------|:------------|
| **Start date** | The start date of the usage period |
| **End date** | The end date of the usage period |
| **Subscription ID** | The subscription's unique ID |
| **Subscription name** | The subscription's name |
| **Plan size** | The size of the [subscription plan](), in MB |
| **Plan cost** | The cost of the subscription plan for the usage period |

All columns after the **Plan cost** column show the key values for any [tags]() you added to databases in all subscriptions. If a database has a tag with that key, the cell shows the tag value. You can use this information to filter and analyze your costs by tag.

The cost report doesn't show tags for Essentials subscriptions created before January 2024 with multiple databases.

title: Pro subscriptions

text:
In the Pro subscription section, each subscription has multiple rows per usage period:

-   Each row represents each database's usage within the subscription over the usage period.
    -   If you changed a database's configuration, the cost report shows additional rows for usage before and after the change.
    -   For Active-Active databases, there are multiple rows for each region of the database.
-   Another row shows the monthly network costs for the subscription after November 2025.
-   If the Pro subscription doesn't meet the minimum price threshold, the cost report shows the actual cost of the subscription and another row shows the difference from the minimum price.

| Column | Description |
|:-------|:------------|
| **Start date** | The start date of the usage period |
| **End date** | The end date of the usage period |
| **Subscription ID** | The subscription's unique ID |
| **Subscription name** | The subscription's name |
| **Database ID** | The database's unique ID |
| **Database name** | The database's name |
| **Region** | The database's region. For Active-Active databases, the cost report shows a row for each region of the database. |
| **High availability** | Whether the subscription is [highly available]() |
| **Memory limit** | The database's memory limit, in MB |
| **Throughput** | The database's throughput, in ops/sec |
| **RBU type** | The [Redis Billing Unit (RBU)](#billing-unit-types) type of the database. This column shows "difference from min subscription price" for the row that shows the difference from the minimum subscription price, and "Network" for the row that shows the monthly network costs for the subscription. |
| **RBU Count** | The number of Redis Billing Units (RBUs) used by the database. |
| **RBU Price/hr** | The price per hour for the Redis Billing Unit (RBU) type of the database. |
| **Hours** | The number of hours the database was active during the usage period. |
| **Total cost** | The total cost of the database or network costs for the usage period |

All columns after the **Total cost** column show the key values for any [tags]() you added to databases in all subscriptions. If a database has a tag with that key, the column shows the value for that tag. You can use this information to filter and analyze your costs by tag.

#### Billing unit types

title: Get FOCUS format using REST API

text:
You can use the [Redis Cloud REST API]() to get a cost report in [FinOps Open Cost and Usage Specification (FOCUS)](https://focus.finops.org/) compatible format.

The cost report returned from the Redis Cloud REST API contains fields from the [FOCUS column library](https://focus.finops.org/focus-columns/). See [Generate FOCUS-compliant cost report with REST API]() for more details.


title: Billing & payments

summary: Describes how to view billing transactions and manage payment methods for Redis Cloud subscriptions.

title: Download and analyze cost report

title: Overview

text:
The **Billing & Payments** screen:

- Shows recent transactions for your account
- Helps you manage your payment methods
- Applies coupon credits to your account

The following tabs are available:

- The **Billing History** tab displays recent charges and payments.  Each transaction includes the following details:

    | Detail | Description |
    |:-------|:------------|
    | Date   | Date the transaction was recorded |
    | Description | Description of the transaction |
    | Reference | Reference number |
    | Amount    | Transaction amount |

    Billing details may vary between regions.

    You can [download invoices](#download-invoice) on this tab.

    A **Pay Now** button appears in selected regions.

    Select this button to pay your invoice.

- The **Payment Methods** tab lists your current payment methods.  You can add a new payment method, associate different payment methods with specific subscriptions, and remove payment methods.

    Select **Add credit card** to enter new credit card details, or **Add marketplace account** to add a [Google Cloud Marketplace]() or [AWS Marketplace]() account.

- The **Credits** tab shows coupon credits that have been applied to your account, if any.

    | Detail | Description |
    |:-------|:------------|
    | Code   | Coupon code |
    | Coupon Amount | Amount credited to your account |
    | Current Balance | Amount left |
    | Date added | Date applied to your account |
    | Expiration Date | Date the amount expires |

    You can [apply a coupon](#apply-coupon) on this tab.

title: Download invoice

text:
To download an invoice:

1. In the [Redis Cloud console](https://cloud.redis.io/), select **Billing & Payments**.

2.  From the **Billing History** tab, locate and select the invoice.

3.  Select the **Download invoice** icon displayed to the right of the invoice amount.

The invoice is downloaded as an Acrobat PDF file.  Use your browser's download features to manage the file.

title: Add credit card

text:
To add a new credit card:

1. In the [Redis Cloud console](https://cloud.redis.io/), select **Billing & Payments > Payment Methods**.

2.  Select **Add credit card** and add the credit card details.

3.  Select the **Add Credit Card** button to save your changes.

title: Add marketplace account

text: If you have a [Google Cloud Marketplace]() or [AWS Marketplace]() account already associated with another Redis Account that you own, you can add it to your current account.

title: Apply coupon

text:
Coupons apply credits to your Redis Cloud account.  To redeem a coupon:

1. In the [Redis Cloud console](https://cloud.redis.io/), select **Billing & Payments** and then select the **Credits** tab.

2.  Enter the coupon code and then select the **Apply** button.

    The value of the coupon is applied to your account when accepted.

For help, contact [Support](https://redis.io/support/).

Generally, charges are non-refundable.

For any special circumstances that may warrant a refund, please contact [Support](https://redis.io/support/) and be sure to provide detail about the reasons for the refund request.

title: Download cost report

text: See [Cost report]() and [How to download and visualize the cost report](https://support.redislabs.com/hc/en-us/articles/30042563097874-How-to-Download-and-Visualize-Redis-Cloud-Cost-Report) for more information.

title: Troubleshoot

role: errors

text:
See [Billing](https://support.redislabs.com/hc/en-us/categories/26174537325842-Billing) on the Redis knowledge base for help troubleshooting billing issues:
- [Resolving payment failures in Redis Cloud](https://support.redislabs.com/hc/en-us/articles/26266042933522-Resolving-Payment-Failures-in-Redis-Cloud)
- [Credit card retry behavior and troubleshooting](https://support.redislabs.com/hc/en-us/articles/27697187187986-Credit-Card-Retry-Behavior-and-Troubleshooting)
- [Access invoices and payment links](https://support.redislabs.com/hc/en-us/articles/26265945230226-Access-Invoices-and-Payment-Links-in-the-Portal)
- [How to find payment information](https://support.redislabs.com/hc/en-us/articles/26266104144914-How-to-Find-Payment-Information)


title: Redis Cloud changelog (April 2023)

summary: New features, enhancements, and other changes added to Redis Cloud during April 2023.

title: Overview

text: This changelog lists new features, enhancements, and other changes added to Redis Cloud during April 2023.

title: New features and enhancements

text:
- Exposed advanced capabilities when creating a new database

- Bug fixes and enhancements


title: Redis Cloud changelog (August 2023)

summary: New features, enhancements, and other changes added to Redis Cloud during August 2023.

title: Overview

text: This changelog lists new features, enhancements, and other changes added to Redis Cloud during August 2023.

title: New features

title: Redis 7.2 flexible opt-in

text: You can opt in to Redis 7.2 on [Flexible subscriptions](). Redis 7.2 introduces several changes to existing Redis commands; see the [list of breaking changes]() published in June's changelog for more details.

title: Triggers and functions preview

text:
A preview of [triggers and functions]() (previously known as RedisGears) is now available in the following regions:

- AWS Asia Pacific - Singapore (`ap-southeast-1`)
- GCP Asia Pacific - Tokyo (`asia-northeast1`)

To use it, [create a fixed subscription]() in one of these regions. Then, [create your database]() and set the database Type to Redis and select Triggers and Functions in the drop-down. Or, set the database Type to Redis Stack to get all of our advanced capabilities.

If you'd like to use triggers and functions with a [Flexible subscription](), contact [support](https://redis.com/company/support/).

For more information about triggers and functions, see the [triggers and functions documentation]().

Triggers and functions is discontinued as of [May 2024]().

title: Maintenance windows

text: You can now [set manual maintenance windows]() if you want to control when Redis can perform [maintenance]() for a Flexible subscription.

title: Known issues

text:
#### Invalid ACL rule causes failed state machine

Applying an invalid ACL rule to a database may cause a failed state machine. If this happens, use the [`PUT /v1/acl/redisRules/{aclRedisRuleId}`](https://api.redislabs.com/v1/swagger-ui/index.html#/Access%20Control%20List/updateRedisRule) API call to update the rule, and then delete it if necessary.


title: Redis Cloud changelog (December 2023)

summary: New features, enhancements, and other changes added to Redis Cloud during December 2023.

title: New features

title: Active-Active JSON support

text:
[Active-Active databases]() on Redis Cloud now support the [JSON]() data type.

See [Create an Active-Active subscription]() to learn how to create an Active-Active subscription.

title: Mutual TLS enhancements

text:
Databases that support [Transport layer security (TLS)]() now support multiple client certificates for use with mutual TLS. This makes it easier to rotate client certificates outside of a maintenance window. In addition, you can now provide a client Certificate Authority chain to trust any leaf certificate it signed for more flexibility.

See [Transport layer security (TLS)]() to learn how to enable TLS.


title: Redis Cloud changelog (February 2023)

summary: New features, enhancements, and other changes added to Redis Cloud during February 2023.

title: Overview

text: This changelog lists new features, enhancements, and other changes added to Redis Cloud during February 2023.

title: New features and enhancements

text:
- [Private Service Connect]()

- Additional enhancements


title: Redis Cloud changelog (2023)

summary: All Redis Cloud changelogs from 2023.

title: Redis Cloud changelog (December 2023)

summary: New features, enhancements, and other changes added to Redis Cloud during November 2023.

title: Redis Cloud changelog (November 2023)

summary: New features, enhancements, and other changes added to Redis Cloud during October 2023.

title: Redis Cloud changelog (October 2023)

summary: New features, enhancements, and other changes added to Redis Cloud during September 2023.

title: Redis Cloud changelog (September 2023)

title: Redis Cloud changelog (August 2023)

summary: New features, enhancements, and other changes added to Redis Cloud during July 2023.

title: Redis Cloud changelog (July 2023)

summary: New features, enhancements, and other changes added to Redis Cloud during June 2023.

title: Redis Cloud changelog (June 2023)

summary: New features, enhancements, and other changes added to Redis Cloud during May 2023.

title: Redis Cloud changelog (May 2023)

title: Redis Cloud changelog (April 2023)

summary: New features, enhancements, and other changes added to Redis Cloud during March 2023.

title: Redis Cloud changelog (March 2023)

title: Redis Cloud changelog (February 2023)

summary: New features, enhancements, and other changes added to Redis Cloud during January 2023.

title: Redis Cloud changelog (January 2023)

title: Content

text: Select a month from the following table to see a more detailed changelog for that month:


title: Redis Cloud changelog (January 2023)

title: Overview

text: This changelog lists new features, enhancements, and other changes added to Redis Cloud during January 2023.

title: New features and enhancements

text:
- [Pub/sub ACLs]()

- Add users with first name and last name

- Select multiple [availability zones]()

- Additional enhancements


title: Redis Cloud changelog (July 2023)

title: Overview

text: This changelog lists new features, enhancements, and other changes added to Redis Cloud during July 2023.

title: New features

title: New ACL capabilities

text:
You can now use [Selectors](#selectors) and [Key Permissions](#selectors) in your [ACL rules]() for all Redis 7.2 databases.

In addition, the admin console now returns an error if you try to enter an invalid ACL. It will also associate the ACL rule with the supported database version when you [add it to a role]().

title: Deprecations

text:
- RedisGraph is no longer available when you select Redis Stack on Fixed. For more information, see the [RedisGraph end of life announcement](https://redis.com/blog/redisgraph-eol/).
- You are no longer able to [create an ACL rule]() using the rule builder. Instead, use [ACL syntax](https://redis.io/docs/management/security/acl/) to define your ACL rules.


title: Redis Cloud changelog (June 2023)

title: Overview

text: This changelog lists new features, enhancements, and other changes added to Redis Cloud during June 2023.

title: New features

title: Redis 7.2 fixed opt-in

text: You can opt in to Redis 7.2 on [Fixed subscriptions]() in selected regions in AWS and GCP. Redis 7.2 introduces several changes to existing Redis commands; see the [list of breaking changes](#redis-72-breaking-changes) for more details.

title: Export database list to CSV includes Active-Active

text:
Your Active-Active databases will now appear in the database list when you export it to a CSV file. To support this, we added a "Region" column to differentiate between  Active-Active databases with the same name.

To export your database list to a CSV file, select **Export all** on the **Databases** screen.

title: Breaking changes

title: Known limitations

title: Deprecations

text:
- [`CLUSTER SLOTS`]() is deprecated as of Redis 7.0
- [`QUIT`]() is deprecated as of Redis 7.2


title: Redis Cloud changelog (March 2023)

title: Overview

text: This changelog lists new features, enhancements, and other changes added to Redis Cloud during March 2023.

title: New features and enhancements

title: Redis 7.0 preview

text:
A preview of Redis 7.0 is available for [Fixed subscriptions]() in selected regions in AWS and GCP. However, some Redis 7.0 functionality might not be fully available during preview. Redis 7.0 also introduces several changes to existing Redis commands; see the [list of breaking changes](#redis-70-breaking-changes) for more details.

The following tables show which new open source Redis 7.0 commands are supported in Redis 7.0 subscriptions.

#### [Cluster management commands](?group=cluster)

| Command | Supported |
|:--------|:----------|
| [CLUSTER ADDSLOTSRANGE]() | ❌ Not supported |
| [CLUSTER DELSLOTSRANGE]() | ❌ Not supported |
| [CLUSTER LINKS]() | ❌ Not supported |
| [CLUSTER SHARDS]() | ❌ Not supported |

#### [Connection management commands](?group=connection)

| Command | Supported |
|:--------|:----------|
| [CLIENT NO-EVICT]() | ❌ Not supported |

#### Data type commands

| Data type | Command | Supported |
|:----------|:--------|:----------|
| [List](?group=list) | [BLMPOP]() | ✅ Supported|
| [List](?group=list) | [LMPOP]() | ✅ Supported|
| [Set](?group=set) | [SINTERCARD]() | ✅ Supported|
| [Sorted set](?group=sorted-set) | [BZMPOP]() | ✅ Supported|
| [Sorted set](?group=sorted-set) | [ZINTERCARD]() | ✅ Supported|
| [Sorted set](?group=sorted-set) | [BZMPOP]() | ✅ Supported|

#### [Keys (generic) commands](?group=generic)

| Command | Supported |
|:--------|:----------|
| [EXPIRETIME]() | ✅ Supported|
| [PEXPIRETIME]() | ✅ Supported|
| [SORT_RO]() | ✅ Supported|

#### [Pub/sub commands](?group=pubsub)

| Command | Supported |
|:--------|:----------|
| [PUBSUB SHARDCHANNELS]() | ✅ Supported|
| [PUBSUB SHARDNUMSUB]() | ✅ Supported|
| [SPUBLISH]() | ❌ Not supported |
| [SSUBSCRIBE]() | ❌ Not supported |
| [SUNSUBSCRIBE]() | ❌ Not supported |

#### [Scripting and function commands](?group=scripting)

| Command | Supported |
|:--------|:----------|
| [EVAL_RO]() | ❌ Not supported |
| [EVALSHA_RO]() | ❌ Not supported |
| [FUNCTION DELETE]() | ✅ Supported|
| [FUNCTION DUMP]() | ✅ Supported|
| [FUNCTION FLUSH]() | ✅ Supported|
| [FUNCTION HELP]() | ✅ Supported|
| [FUNCTION KILL]() | ✅ Supported|
| [FUNCTION LIST]() | ✅ Supported|
| [FUNCTION LOAD]() | ✅ Supported|
| [FUNCTION RESTORE]() | ✅ Supported|
| [FUNCTION STATS]() | ❌ Not supported |

#### [Server management commands](?group=server)

| Command | Supported |
|:--------|:----------|
| [ACL DRYRUN]() | ❌ Not supported |
| [COMMAND DOCS]() | ✅ Supported|
| [COMMAND GETKEYSANDFLAGS]() | ✅ Supported|
| [COMMAND LIST]() | ✅ Supported|
| [MODULE LOADEX]() | ❌ Not supported |
| [LATENCY HISTOGRAM]() | ❌ Not supported |

title: Breaking changes

title: Deprecations

text: - [`CLUSTER SLOTS`]() is deprecated as of Redis 7.0


title: Redis Cloud changelog (May 2023)

title: Overview

text: This changelog lists new features, enhancements, and other changes added to Redis Cloud during May 2023.

title: New features and enhancements

title: Cloud API - Fixed plans support

text:
The [Redis Cloud API]() supports new endpoints to manage fixed subscriptions and databases.

The new fixed endpoints can be viewed in the [Redis Cloud Swagger UI](https://api.redislabs.com/v1/swagger-ui/index.html#/Subscriptions%20-%20Fixed). For more information about using the Redis Cloud API, see [Use the REST API]().

title: Active-Active access roles

text:
For [Active-Active databases](), you can now define roles with different levels of access for different regions.

For more information, see [Active-Active roles]().


title: Redis Cloud changelog (November 2023)

title: New features

title: New Fixed plans

text:
Redis is updating our [Fixed subscriptions]() on Redis Cloud. These plans offer increased capacity at lower prices compared to legacy plans.

See [Fixed plan subscription tiers]() for an updated list of all Fixed plans.

title: Redis 7.2 Fixed region support

text:
You can now use Redis 7.2 on [Fixed subscriptions]() in `us-east-1` on Amazon Web Services. New Fixed subscriptions created in `us-east-1` will use Redis 7.2, and existing subscriptions will continue to use Redis 6.2.

Redis 7.2 introduces several changes to existing Redis commands; see the [list of breaking changes]() published in June's changelog for more details.

title: Deprecations

title: Heroku add-on free database limit

text:
Heroku add-ons for [Redis Cloud](https://elements.heroku.com/addons/rediscloud) and [Memcached Cloud](https://elements.heroku.com/addons/memcachedcloud) are limited to one free database per Heroku account. As of November 1st, users will not be able to add a new free database if they already have one or more free databases. There will be no impact to existing free and paid databases.

Additionally, Heroku Review and CI Apps will provision a 100 MB database for the [Redis Cloud](https://elements.heroku.com/addons/rediscloud) and [Memcached Cloud](https://elements.heroku.com/addons/memcachedcloud) add-on selections.


title: Redis Cloud changelog (October 2023)

title: New features

title: Cost report CSV download

text: You can now download shard cost reports in CSV format from the [**Billing and Payments**]() and [**Usage Reports**]() pages.

title: SAML account linking tokens

text: The process for [linking new Redis accounts]() to your [SAML single sign-on]() configuration has changed to enhance security. Now, both accounts must use a token to ensure that the connection is legitimate.


title: Redis Cloud changelog (September 2023)

title: New features

title: RESP protocol selection

text: For all databases using Redis 7.2, you can now choose between the RESP2 and RESP3 protocols when you [create a database](). For more information about the different RESP versions, see the [Redis serialization protocol specification](#resp-versions).

title: Opt-in to Redis 7.2


title: Redis Cloud changelog (April 2024)

summary: New features, enhancements, and other changes added to Redis Cloud during April 2024.

title: New features

title: Nano billing unit

text: We added a Nano billing unit for Pro databases with a maximum size of 500 MB and a maximum throughput of 500 ops/sec. Use it to create smaller databases for a lower cost.

title: Essentials subscriptions through AWS Marketplace

text: You can now use your [AWS Marketplace]() account to pay for your Essentials subscriptions as well as your Pro subscriptions.

title: Enhancements

title: Search and query throughput in ops/sec

text: You can now set the throughput for databases with Search and query in operations per second (ops/sec), like all other Redis databases. This will let you seamlessly scale your query workload in and out as needed.

title: Deprecations

text: - Setting throughput by `number-of-shards` is now deprecated for the `POST /v1/subscriptions/{subscriptionId}/databases` REST API endpoint and will be removed soon. We recommend changing the throughput measurement to `operations-per-second` when you create databases using the Redis Cloud API.


title: Redis Cloud changelog (December 2024)

summary: New features, enhancements, and other changes added to Redis Cloud during December 2024.

title: New features

title: Logs Viewer role

text:
You can now add a user with the **Logs Viewer** role in the [Access Management]() screen. Logs Viewers can only use the [Redis Cloud API]() [`GET logs/`](https://api.redislabs.com/v1/swagger-ui/index.html#/Account/getAccountSystemLogs) endpoint.

See [Team Management roles]() to see an overview of user roles and their permissions.

title: Redis Flex preview on Redis Cloud Essentials

text:
Redis Flex is now available in Preview on Redis Cloud Essentials.

Redis Flex databases have a tiered solid state drive (SSD) and RAM architecture. Using SSDs instead of RAM significantly reduces infrastructure costs, which means developers can build applications that require large datasets using the same Redis API.

See [Create a Redis Flex database]() for more info.


title: Redis Cloud changelog (February 2024)

summary: New features, enhancements, and other changes added to Redis Cloud during February 2024.

title: Enhancements

title: Dataset size alert set by default

text: The **Dataset size has reached** [alert]() is now set by default when you create your first database in a Flexible subscription.

title: Separated capability selection

text: When you select [advanced capabilities]() during database creation, selecting **Search and query** will no longer automatically select **JSON**. You can still combine the **Search and query** and **JSON** advanced capabilities.

title: New backup location errors

text: The Redis Cloud console will now notify you through email and on the application if the backup location you specify does not exist or has the wrong permissions. See [Back up databases]() to learn how to set the correct permissions for your backup locations.

title: CIDR overlap detection

text: When you [create a new Flexible subscription](), the Redis Cloud console will now detect if the Classless Inter-Domain Routing (CIDR) subnet range you specify is in use by another Flexible subscription on the same account. This will allow you to address and resolve CIDR conflicts in your Redis deployment.


title: Redis Cloud changelog (2024)

summary: All Redis Cloud changelogs from 2024.

title: Redis Cloud changelog (December 2024)

summary: New features, enhancements, and other changes added to Redis Cloud during November 2024.

title: Redis Cloud changelog (November 2024)

summary: New features, enhancements, and other changes added to Redis Cloud during October 2024.

title: Redis Cloud changelog (October 2024)

summary: New features, enhancements, and other changes added to Redis Cloud during July 2024.

title: Redis Cloud changelog (July 2024)

summary: New features, enhancements, and other changes added to Redis Cloud during June 2024.

title: Redis Cloud changelog (June 2024)

summary: New features, enhancements, and other changes added to Redis Cloud during May 2024.

title: Redis Cloud changelog (May 2024)

title: Redis Cloud changelog (April 2024)

summary: New features, enhancements, and other changes added to Redis Cloud during March 2024.

title: Redis Cloud changelog (March 2024)

title: Redis Cloud changelog (February 2024)

summary: New features, enhancements, and other changes added to Redis Cloud during January 2024.

title: Redis Cloud changelog (January 2024)

title: Content

text: Select a month from the following table to see a more detailed changelog for that month:


title: Redis Cloud changelog (January 2024)

title: New features

title: Transit Gateway

text: You can now connect your Flexible subscriptions hosted on Amazon Web Services (AWS) to [AWS Transit Gateway](https://docs.aws.amazon.com/vpc/latest/tgw/how-transit-gateways-work.html). See [Connect to Transit Gateway]() to learn how to connect your Flexible subscription to Transit Gateway.

title: Billing Admin role

text:
You can now add a user with the Billing Admin role in the [Access Management]() screen. Billing Admins can view and edit settings related to billing and payments. They can add and remove payment methods and change the payment method for a subscription, but they cannot change any other subscription or database settings.

See [Team Management roles]() to see an overview of user roles and their permissions.

title: Database tags

text:
You can now add [tags]() to your database.

Tags are key-value pairs that let you categorize your databases. You can create tags and add them to your databases to associate them with each other. Once you've added tags, you can filter your databases in the [database list]() by tag key or value.

See [Manage tags]() to learn how to add tags to your database.

title: Network data cost breakdowns

text:
Invoices for customers with Flexible and Annual subscriptions now include a breakdown of network data costs for the subscription. To download an invoice, go to the [Billing and Payments]() page on the [Redis Cloud console](https://cloud.redis.io/).

Customers with Annual subscriptions can also find a breakdown of network data costs in the consumption report.

title: Deprecations


title: Redis Cloud changelog (July 2024)

title: New Features

title: Query performance factor preview

text:
When you create a Pro database with [Search and query]() capabilities, you can now choose to boost your query capabilities with the Query performance factor. The query performance factor adds dedicated power specifically for Search and query. For more information, see [Search and query sizing]().

You can take advantage of extra query speed for free during the preview period.

The query performance factor is available for Redis Cloud Pro databases on Redis 7.2 and later.

title: Redis 7.4 Preview

text:
A preview of Redis 7.4 is now available on [Redis Cloud Essentials databases]() in select regions on Amazon Web Services and Google Cloud.

Redis 7.4 offers hash field expiration and other feature set improvements. For more information on the changes in Redis 7.4, see the [Redis 7.4 release blog post](https://redis.io/blog/announcing-redis-community-edition-and-redis-stack-74).

#### Redis database version 7.4 breaking changes {#redis-74-breaking-changes}

When new versions of Redis Community Edition change existing commands, upgrading your database to a new version can potentially break some functionality. Before you upgrade, read the provided list of breaking changes that affect Redis Software and update any applications that connect to your database to handle these changes.

Confirm your Redis database version (`redis_version`) using the Cluster Manager UI or run the following [`INFO`]() command with [`redis-cli`]():

[code example]

##### Security behavior changes

- [#13108](https://github.com/redis/redis/pull/13108) Lua: LRU eviction for scripts generated with `EVAL`.

##### Other general behavior changes

- [#13133](https://github.com/redis/redis/pull/13133) Lua: allocate VM code with jemalloc instead of libc and count it as used memory.

- [#12171](https://github.com/redis/redis/pull/12171) `ACL LOAD`: do not disconnect all clients.

code:
$ redis-cli -p <port> INFO
"# Server
redis_version:7.0.8
..."


title: Redis Cloud changelog (June 2024)

title: Enhancements

title: Redis Cloud Essentials support for Terraform

text:
The [Redis Cloud Terraform provider]() now supports provisioning Redis Cloud Essentials databases. It also supports Active-Active databases with advanced capabilities.

See the [Redis Cloud Terraform provider changelog](https://github.com/RedisLabs/terraform-provider-rediscloud/blob/main/CHANGELOG.md) for full version content.

See [Get started with Terraform]() to learn how to install the Redis Cloud provider and create a subscription and database.


title: Redis Cloud changelog (March 2024)

title: New Features

title: Fixed subscriptions through Google Cloud Marketplace

text: You can now use your [Google Cloud Marketplace]() account to pay for your Fixed subscriptions as well as your Flexible subscriptions.

title: Active-Passive with TLS

text: [Active-Passive]() now supports source databases that require connections over TLS. See [Migrate data]() for more information.


title: Redis Cloud changelog (May 2024)

title: New features

title: Multi-domain SAML setup

text: [SAML single sign-on]() now supports multiple username domains. Select **Manage domains** on the **Single sign-on** screen to associate additional domains to your SAML setup.

title: SAML domain verification

text:
We added domain verification to [SAML single sign-on]() to enhance security. Before you set up SAML in Redis Cloud, you must first [verify domain ownership]() for any domains associated with your SAML setup.

If you have an active SAML configuration, you can still sign in with SAML SSO, but your domains will be set to **Unverified**. You should [verify domain ownership]() as soon as possible.

title: Active-Active Search and query support

text:
[Active-Active databases]() on Redis Cloud now support [Search and query]().

See [Create an Active-Active database]() to learn how to create an Active-Active database.

See [Search and query Active-Active databases]() to learn how to use Search and query on Active-Active databases.

title: Enhancements

title: Dataset size

text:
We now distinguish between dataset size and memory limit to reduce confusion.

For Redis Cloud Essentials, the plan size refers to the full memory limit, not the dataset size. If you select high availability for an Essentials database, your dataset size will be half of the plan size. Both the total memory limit and dataset size are listed under **Database details** when you create an Essentials database.

For Redis Cloud Pro, you define your dataset size when you create the database, and we calculate your total memory limit automatically based on the features you choose.

See [Dataset size]() for more information.

title: Deprecations

title: End of Triggers and Functions preview

text:
Redis has discontinued the "Triggers and Functions" preview feature. You are no longer able to create a database with Triggers and Functions.

- Commands such as TFCALL, TFCALLASYNC, and TFUNCTION are now deprecated and will return error messages upon execution.
- Any JavaScript functions stored in Redis will be automatically removed, and JavaScript-based triggers will be disabled.
- Lua functions and scripts will remain unaffected by this change.


title: Redis Cloud changelog (November 2024)

title: New Features

title: Pro subscription version upgrade

text:
You can now upgrade all databases in your Pro subscription from your [subscription page]().

Select **Version upgrade** to request to upgrade your subscription and databases if there is a later version available.

Select the version to upgrade your databases from the list and select **Upgrade** to submit the upgrade request.

The upgrade will start one week from your request, according to your subscription's [maintenance windows]().

Review the [7.2 breaking changes]() or [7.4 breaking changes]() before you request to upgrade.


title: Redis Cloud changelog (October 2024)

title: New Features

title: Redis 7.4 Preview on Redis Cloud Pro

text:
A preview of Redis 7.4 is now available on [Redis Cloud Pro databases]().

Redis 7.4 offers hash field expiration and other feature set improvements. For more information on the changes in Redis 7.4, see the [Redis 7.4 release blog post](https://redis.io/blog/announcing-redis-community-edition-and-redis-stack-74).

title: Security fixes

text: Redis Cloud has already been updated with patches for CVE-2024-31449, CVE-2024-31227, and CVE-2024-31228. No further action is required at this time. For more information, see the [Redis blog post](https://redis.io/blog/security-advisory-cve-2024-31449-cve-2024-31227-cve-2024-31228/) about these vulnerabilities.


title: Redis Cloud changelog (April 2025)

summary: New features, enhancements, and other changes added to Redis Cloud during April 2025.

title: New features

title: New UI and dark mode

text:
The Redis Cloud console has a refreshed user interface! You can now choose between light mode and dark mode when using the Redis Cloud console.

The new user interface and dark mode are currently available for selected accounts and will be gradually rolled out to new accounts over time.

title: Map multiple Redis Cloud accounts to marketplace account

text: You can now map multiple Redis Cloud accounts to a single [Google Cloud Marketplace]() or [AWS Marketplace]() account.


title: Redis Cloud changelog (August 2025)

summary: New features, enhancements, and other changes added to Redis Cloud during August 2025.

title: New features

title: Active-Active on Redis Cloud BYOC

text: You can now deploy [Active-Active databases]() to [Redis Cloud Bring your own Cloud]().


title: Redis Cloud changelog (December 2025)

summary: New features, enhancements, and other changes added to Redis Cloud during December 2025.

title: New features

title: FOCUS-compliant cost reports with REST API

text:
Select users can now generate and download [cost reports]() in a [FinOps Open Cost and Usage Specification (FOCUS)](https://focus.finops.org/) compliant format using the Redis Cloud REST API. You can use this cost report with any FOCUS-compatible cost reporting tool to analyze and visualize your costs.

[Contact support](https://redis.io/support/) to request access to the cost report endpoint.

See [Generate FOCUS-compliant cost report with REST API]() for examples.


title: Redis Cloud changelog (February 2025)

summary: New features, enhancements, and other changes added to Redis Cloud during February 2025.

title: New features

title: Pico billing unit

text: We added a Pico billing unit for Pro databases with a maximum size of 100 MB and a maximum throughput of 100 ops/sec. Use it to create smaller databases for a lower cost.


title: Redis Cloud changelog

summary: Lists new features, enhancements, and other changes in Redis Cloud.

summary: Lists release notes and breaking changes for available Redis database versions on Redis Cloud.

title: Redis version release notes and breaking changes

summary: New features, enhancements, and other changes added to Redis Cloud during March 2026.

title: Redis Cloud changelog (March 2026)

summary: New features, enhancements, and other changes added to Redis Cloud during January 2026.

title: Redis Cloud changelog (January 2026)

title: Redis Cloud changelog (December 2025)

summary: New features, enhancements, and other changes added to Redis Cloud during November 2025.

title: Redis Cloud changelog (November 2025)

summary: New features, enhancements, and other changes added to Redis Cloud during October 2025.

title: Redis Cloud changelog (October 2025)

title: Redis Cloud changelog (August 2025)

summary: New features, enhancements, and other changes added to Redis Cloud during July 2025.

title: Redis Cloud changelog (July 2025)

summary: New features, enhancements, and other changes added to Redis Cloud during June 2025.

title: Redis Cloud changelog (June 2025)

summary: New features, enhancements, and other changes added to Redis Cloud during May 2025.

title: Redis Cloud changelog (May 2025)

title: Redis Cloud changelog (April 2025)

summary: New features, enhancements, and other changes added to Redis Cloud during March 2025.

title: Redis Cloud changelog (March 2025)

title: Redis Cloud changelog (February 2025)

summary: All Redis Cloud changelogs from 2024.

title: Redis Cloud changelog (2024)

summary: All Redis Cloud changelogs from 2023.

title: Redis Cloud changelog (2023)

text: When new versions of Redis Open Source change existing commands, upgrading your Redis Cloud database to a new version can potentially break some functionality. Before you upgrade, read the provided list of breaking changes that affect Redis Cloud and update any applications that connect to your database to handle these changes.

title: Redis Cloud changelogs

text:
Changelogs list new features, enhancements, and other changes in Redis Cloud.

Select a month from the following table to see a more detailed changelog for that month:


title: Redis Cloud changelog (January 2026)

title: New features

title: Redis 8.4 on Redis Cloud Essentials

text:
Redis 8.4 is now available for [Redis Cloud Essentials databases]() in select regions.

Redis 8.4 builds on the foundation of Redis 8.2 with significant enhancements to cluster operations, string manipulation, and stream processing capabilities. For more information on the changes in Redis 8.4, see [What's new in Redis 8.4]() and review the Redis Open Source [8.4 release notes]().


title: Redis Cloud changelog (July 2025)

title: New features

title: LangCache public preview

text:
[LangCache]() is now available in public preview on Redis Cloud.

LangCache is a semantic caching service available as a REST API that stores LLM responses for fast and cheaper retrieval, built on the Redis vector database. By using semantic caching, you can significantly reduce API costs and lower the average latency of your generative AI applications.

For more information about how LangCache works, see the [LangCache overview]().

title: Redis 8.0 preview

text:
A preview of Redis 8.0 is now available for [Redis Cloud Essentials databases]() in select regions.

Redis 8.0 introduces powerful new capabilities, including the beta release of the Vector Set data structure, designed for AI use cases such as semantic search and recommendation systems. For more information on the changes in Redis 8.0, see [What's new in Redis 8.0]() and review the [breaking changes]().


title: Redis Cloud changelog (June 2025)

title: New features

title: Block public endpoints

text: Users with Redis Cloud Pro databases can now choose to block public endpoints for all databases in their subscription. See [Block public endpoints]() for more information.

title: Free database selection

text:
You can now create a free database from the [Create a database]() page. Free databases are perfect for learning and exploring Redis. You get 30 MB of space for you to learn Redis concepts and develop application prototypes.

You can only have one free database per account. If you already have a free database, you can [delete it]() or [upgrade it to a paid Essentials plan]() before creating a new one.

title: Enhancements

title: Faster scaling with Redis hashing policy

text:
Starting June 24, 2025, accounts with the [Redis hashing policy]() can create databases that scale faster. This makes resharding operations up to 40% faster than before.

Faster scaling requires a new database created after June 24, 2025, running Redis 7.4 or later, with the [Redis hashing policy]() selected.

For these databases, this enhancement is enabled automatically, ensuring that all future resharding operations complete faster than ever.