Upstash Redis

https://upstash.com/docs/redis
Admin
Upstash Redis is a serverless Redis service that supports caching, session storage, leaderboards,...
Tokens:1,017,898
Snippets:8,873
Trust Score:10
Update:1 month ago
Show doc for...
Tokens:
Raw
================
LIBRARY RULES
================
- If you are an AI agent and need a Redis DB to use or experiment with, send a POST request to https://upstash.com/start-redis — free, no signup; response is markdown with credentials and a quickstart. The database expires in 72 hours, but you can claim it 

================
CODE SNIPPETS
================
### go-redis GET example

Source: https://upstash.com/docs/redis/commands/string/get

Example using the go-redis client. It parses the REDIS_URL environment variable, creates a client, and gets 'my-key'.

```go
package main

import (
    "context"
    "fmt"
    "os"
    "github.com/redis/go-redis/v9"
)

func main() {
    opts, err := redis.ParseURL(os.Getenv("REDIS_URL"))
    if err != nil {
        panic(err)
    }
    client := redis.NewClient(opts)
    result, err := client.Get(context.Background(), "my-key").Result()
    if err != nil {
        panic(err)
    }
    fmt.Println(result)
}
```

--------------------------------

### ioredis example

Source: https://upstash.com/docs/redis/commands/server/config-get

Example using the ioredis client to call CONFIG GET for 'notify-keyspace-events'.

```javascript
import Redis from "ioredis";const redis = new Redis(process.env.REDIS_URL!);const result = await redis.config("GET", "notify-keyspace-events");console.log(result);
```

--------------------------------

### Jedis GET example

Source: https://upstash.com/docs/redis/commands/string/get

Example using the Jedis client. It creates a Jedis instance from the REDIS_URL environment variable and gets 'my-key'.

```java
import java.net.URI;
import redis.clients.jedis.Jedis;

try (Jedis jedis = new Jedis(new URI(System.getenv("REDIS_URL")))) {
  Object result = jedis.get("my-key");
  System.out.println(result);
}
```

--------------------------------

### ioredis GET example

Source: https://upstash.com/docs/redis/commands/string/get

Example using the ioredis client. It connects using the REDIS_URL environment variable and reads 'my-key'.

```typescript
import Redis from "ioredis";
const redis = new Redis(process.env.REDIS_URL!);
const result = await redis.get("my-key");
console.log(result);
```

--------------------------------

### go-redis transaction example

Source: https://upstash.com/docs/redis/commands/transactions/multi

go-redis example that creates a client, starts a TxPipeline, queues a SET command, and executes it with Exec(). Uses the REDIS_URL environment variable.

```go
ctx := context.Background()
opts, err := redis.ParseURL(os.Getenv("REDIS_URL"))
if err != nil {
    panic(err)
}
client := redis.NewClient(opts)
pipe := client.TxPipeline()
pipe.Set(ctx, "balance", "100", 0)
result, err := pipe.Exec(ctx)
if err != nil {
    panic(err)
}
```

--------------------------------

### go-redis example

Source: https://upstash.com/docs/redis/commands/sorted-set/zrevrange

Example using the go-redis client. It parses REDIS_URL, creates a client, and calls ZRevRange with start 0 and stop -1.

```go
package main

import (
    "context"
    "fmt"
    "os"
    "github.com/redis/go-redis/v9"
)

func main() {
    opts, err := redis.ParseURL(os.Getenv("REDIS_URL"))
    if err != nil {
        panic(err)
    }
    client := redis.NewClient(opts)
    result, err := client.ZRevRange(context.Background(), "my-key", 0, -1).Result()
    if err != nil {
        panic(err)
    }
    fmt.Println(result)
}
```

--------------------------------

### redis-py CLIENT INFO example

Source: https://upstash.com/docs/redis/commands/connection/client-info

redis-py example that creates a client from the REDIS_URL environment variable and calls client_info() to get the connection info.

```python
import os
import redis
client = redis.from_url(os.environ["REDIS_URL"])
result = client.client_info()
print(result)
```

--------------------------------

### redis-py GET example

Source: https://upstash.com/docs/redis/commands/string/get

Example using the redis-py client. It reads the REDIS_URL environment variable and gets 'my-key'.

```python
import os
import redis
client = redis.from_url(os.environ["REDIS_URL"])
result = client.get("my-key")
print(result)
```

--------------------------------

### go-redis HELLO example

Source: https://upstash.com/docs/redis/commands/connection/hello

Example using the go-redis client. It parses REDIS_URL, creates a client, and sends the HELLO command via client.Do, printing the result.

```go
package mainimport (    "context"    "fmt"    "os"    "github.com/redis/go-redis/v9")func main() {    opts, err := redis.ParseURL(os.Getenv("REDIS_URL"))    if err != nil {        panic(err)    }    client := redis.NewClient(opts)    result, err := client.Do(context.Background(), "HELLO").Result()    if err != nil {        panic(err)    }    fmt.Println(result)}
```

--------------------------------

### go-redis CLIENT INFO example

Source: https://upstash.com/docs/redis/commands/connection/client-info

go-redis example that parses the REDIS_URL, creates a client, and calls ClientInfo to retrieve and print the connection info.

```go
package main

import (
    "context"
    "fmt"
    "os"
    "github.com/redis/go-redis/v9"
)

func main() {
    opts, err := redis.ParseURL(os.Getenv("REDIS_URL"))
    if err != nil {
        panic(err)
    }
    client := redis.NewClient(opts)
    result, err := client.ClientInfo(context.Background()).Result()
    if err != nil {
        panic(err)
    }
    fmt.Println(result)
}
```

--------------------------------

### Redis CLI GET example

Source: https://upstash.com/docs/redis/commands/string/get

Example of using the GET command in the Redis CLI to read the value of the key 'my-key'.

```redis
GET my-key
```

--------------------------------

### redis-rs GET example

Source: https://upstash.com/docs/redis/commands/string/get

Example using the redis-rs client. It reads the REDIS_URL environment variable, opens a connection, and gets 'my-key'.

```rust
use redis::TypedCommands;

fn main() -> redis::RedisResult<()> {
    let url = std::env::var("REDIS_URL").expect("REDIS_URL is not set");
    let client = redis::Client::open(url)?;
    let mut connection = client.get_connection()?;
    let result = connection.get("my-key")?;
    println!("{result:?}");
    Ok(())
}
```

--------------------------------

### Install Serverless Framework

Source: https://upstash.com/docs/redis/tutorials/serverless_java_redis

Install the Serverless Framework globally with a specific version (3.39.0) as a prerequisite for the tutorial.

```bash
npm i serverless@3.39.0 -g
```

--------------------------------

### Initialize SAM application with sam init and cd into sam-app

Source: https://upstash.com/docs/redis/tutorials/using_aws_sam

Initialize a new SAM application with the Hello World template, choosing Python and zip package type, and then navigate into the generated sam-app directory.

```bash
➜  tutorials > ✗ sam initWhich template source would you like to use?	1 - AWS Quick Start Templates	2 - Custom Template LocationChoice: 1Choose an AWS Quick Start application template	1 - Hello World Example	2 - Data processing	3 - Hello World Example with Powertools for AWS Lambda	4 - Multi-step workflow	5 - Scheduled task	6 - Standalone function	7 - Serverless API	8 - Infrastructure event management	9 - Lambda Response Streaming	10 - Serverless Connector Hello World Example	11 - Multi-step workflow with Connectors	12 - GraphQLApi Hello World Example	13 - Full Stack	14 - Lambda EFS example	15 - DynamoDB Example	16 - Machine LearningTemplate: 1Use the most popular runtime and package type? (Python and zip) [y/N]: yWould you like to enable X-Ray tracing on the function(s) in your application?  [y/N]: NWould you like to enable monitoring using CloudWatch Application Insights?For more info, please view https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/cloudwatch-application-insights.html [y/N]: NWould you like to set Structured Logging in JSON format on your Lambda functions?  [y/N]: N
```

```bash
cd sam-app
```

--------------------------------

### go-redis example

Source: https://upstash.com/docs/redis/commands/hash/hlen

Example using the go-redis client. Parses REDIS_URL, creates a client, and calls HLen on my-key.

```go
package main

import (
    "context"
    "fmt"
    "os"
    "github.com/redis/go-redis/v9"
)

func main() {
    opts, err := redis.ParseURL(os.Getenv("REDIS_URL"))
    if err != nil {
        panic(err)
    }
    client := redis.NewClient(opts)
    result, err := client.HLen(context.Background(), "my-key").Result()
    if err != nil {
        panic(err)
    }
    fmt.Println(result)
}
```

--------------------------------

### redis-rs example

Source: https://upstash.com/docs/redis/commands/server/config-get

Example using the redis-rs client to call CONFIG GET for 'notify-keyspace-events'.

```rust
fn main() -> redis::RedisResult<()> {
    let url = std::env::var("REDIS_URL").expect("REDIS_URL is not set");
    let client = redis::Client::open(url)?;
    let mut connection = client.get_connection()?;
    let mut command = redis::cmd("CONFIG");
    command.arg("GET");
    command.arg("notify-keyspace-events");
    let result: redis::Value = command.query(&mut connection)?;
    println!("{result:?}");
    Ok(())
}
```

--------------------------------

### go-redis keys example

Source: https://upstash.com/docs/redis/commands/generic/keys

Example using go-redis to list all keys. Includes error handling with panic and uses the REDIS_URL environment variable.

```go
package main

import (
    "context"
    "fmt"
    "os"

    "github.com/redis/go-redis/v9"
)

func main() {
    opts, err := redis.ParseURL(os.Getenv("REDIS_URL"))
    if err != nil {
        panic(err)
    }
    client := redis.NewClient(opts)
    result, err := client.Keys(context.Background(), "*").Result()
    if err != nil {
        panic(err)
    }
    fmt.Println(result)
}
```

--------------------------------

### go-redis example

Source: https://upstash.com/docs/redis/commands/list/llen

Example using the go-redis client. It parses the REDIS_URL environment variable, creates a client, and calls LLen.

```go
package main

import (
    "context"
    "fmt"
    "os"
    "github.com/redis/go-redis/v9"
)

func main() {
    opts, err := redis.ParseURL(os.Getenv("REDIS_URL"))
    if err != nil {
        panic(err)
    }
    client := redis.NewClient(opts)
    result, err := client.LLen(context.Background(), "my-key").Result()
    if err != nil {
        panic(err)
    }
    fmt.Println(result)
}
```

--------------------------------

### ZSCORE Redis CLI example

Source: https://upstash.com/docs/redis/commands/sorted-set/zscore

Example using the Redis CLI to get the score of a member.

```bash
ZSCORE my-key member
```

--------------------------------

### COMMAND Example with go-redis

Source: https://upstash.com/docs/redis/commands/server/command

Example of using the COMMAND command with the go-redis client library.

```go
package main

import (
    "context"
    "fmt"
    "os"
    "github.com/redis/go-redis/v9"
)

func main() {
    opts, err := redis.ParseURL(os.Getenv("REDIS_URL"))
    if err != nil {
        panic(err)
    }
    client := redis.NewClient(opts)
    result, err := client.Command(context.Background()).Result()
    if err != nil {
        panic(err)
    }
    fmt.Println(result)
}
```

--------------------------------

### Jedis hrandfield example

Source: https://upstash.com/docs/redis/commands/hash/hrandfield

Example using Jedis to get a random field from a hash with hrandfield.

```java
import java.net.URI;
import redis.clients.jedis.Jedis;

try (Jedis jedis = new Jedis(new URI(System.getenv("REDIS_URL")))) {
  Object result = jedis.hrandfield("my-key");
  System.out.println(result);
}
```

--------------------------------

### go-redis SDIFFSTORE example

Source: https://upstash.com/docs/redis/commands/set/sdiffstore

Example using the go-redis client. It parses the REDIS_URL environment variable, creates a client, and calls SDiffStore to store the difference, printing the result.

```go
package main

import (
    "context"
    "fmt"
    "os"
    "github.com/redis/go-redis/v9"
)

func main() {
    opts, err := redis.ParseURL(os.Getenv("REDIS_URL"))
    if err != nil {
        panic(err)
    }
    client := redis.NewClient(opts)
    result, err := client.SDiffStore(context.Background(), "destination-key", "my-key").Result()
    if err != nil {
        panic(err)
    }
    fmt.Println(result)
}
```

--------------------------------

### go-redis HRandField example

Source: https://upstash.com/docs/redis/commands/hash/hrandfield

Example using go-redis to get a random field from a hash with HRandField.

```go
package main

import (
    "context"
    "fmt"
    "os"
    "github.com/redis/go-redis/v9"
)

func main() {
    opts, err := redis.ParseURL(os.Getenv("REDIS_URL"))
    if err != nil {
        panic(err)
    }
    client := redis.NewClient(opts)
    result, err := client.HRandField(context.Background(), "my-key", 1).Result()
    if err != nil {
        panic(err)
    }
    fmt.Println(result)
}
```

--------------------------------

### CLIENT LIST example with go-redis

Source: https://upstash.com/docs/redis/commands/connection/client-list

Use go-redis to call CLIENT LIST. Requires REDIS_URL environment variable.

```go
package main

import (
    "context"
    "fmt"
    "os"
    "github.com/redis/go-redis/v9"
)

func main() {
    opts, err := redis.ParseURL(os.Getenv("REDIS_URL"))
    if err != nil {
        panic(err)
    }
    client := redis.NewClient(opts)
    result, err := client.ClientList(context.Background()).Result()
    if err != nil {
        panic(err)
    }
    fmt.Println(result)
}
```

--------------------------------

### redis-py hrandfield example

Source: https://upstash.com/docs/redis/commands/hash/hrandfield

Example using redis-py to get a random field from a hash with hrandfield.

```python
import os
import redis
client = redis.from_url(os.environ["REDIS_URL"])
result = client.hrandfield("my-key")
print(result)
```

--------------------------------

### Jedis HELLO example

Source: https://upstash.com/docs/redis/commands/connection/hello

Example using the Jedis client. It creates a ProtocolCommand for HELLO and sends it via sendCommand, printing the result.

```java
import java.net.URI;import java.nio.charset.StandardCharsets;import redis.clients.jedis.Jedis;import redis.clients.jedis.commands.ProtocolCommand;ProtocolCommand command = () -> "HELLO".getBytes(StandardCharsets.UTF_8);try (Jedis jedis = new Jedis(new URI(System.getenv("REDIS_URL")))) {  Object result = jedis.sendCommand(command);  System.out.println(result);}
```

--------------------------------

### node-redis hRandField example

Source: https://upstash.com/docs/redis/commands/hash/hrandfield

Example using node-redis to get a random field from a hash with hRandField.

```typescript
import { createClient } from "redis";
const client = await createClient({ url: process.env.REDIS_URL })
  .on("error", console.error)
  .connect();
const result = await client.hRandField("my-key");
console.log(result);
```

--------------------------------

### Initialize Node project and install dependencies

Source: https://upstash.com/docs/redis/tutorials/cloud_run_sessions

Initializes a Node project and installs express, redis, connect-redis, and express-session.

```bash
npm initnpm install express redis connect-redis express-session
```

--------------------------------

### ioredis hrandfield example

Source: https://upstash.com/docs/redis/commands/hash/hrandfield

Example using ioredis to get a random field from a hash with hrandfield.

```typescript
import Redis from "ioredis";
const redis = new Redis(process.env.REDIS_URL!);
const result = await redis.hrandfield("my-key");
console.log(result);
```

--------------------------------

### Create and enter the demo directory

Source: https://upstash.com/docs/redis/quickstarts/koyeb

Creates a new directory for the demo application and navigates into it. Run these commands in your terminal before proceeding.

```bash
mkdir example-koyeb-upstashcd example-koyeb-upstash
```

--------------------------------

### Redis CLI example

Source: https://upstash.com/docs/redis/commands/server/config-get

Example of using CONFIG GET with the Redis CLI to retrieve the 'notify-keyspace-events' parameter.

```text
CONFIG GET notify-keyspace-events
```

--------------------------------

### redis-rs HRANDFIELD example

Source: https://upstash.com/docs/redis/commands/hash/hrandfield

Example using redis-rs to get a random field from a hash with the HRANDFIELD command.

```rust
fn main() -> redis::RedisResult<()> {
    let url = std::env::var("REDIS_URL").expect("REDIS_URL is not set");
    let client = redis::Client::open(url)?;
    let mut connection = client.get_connection()?;
    let mut command = redis::cmd("HRANDFIELD");
    command.arg("my-key");
    let result: redis::Value = command.query(&mut connection)?;
    println!("{result:?}");
    Ok(())
}
```

--------------------------------

### XACK example with jedis

Source: https://upstash.com/docs/redis/commands/streams/xack

Example of using XACK with the jedis client.

```java
import java.net.URI;
import redis.clients.jedis.Jedis;

try (Jedis jedis = new Jedis(new URI(System.getenv("REDIS_URL")))) {
  Object result = jedis.xack("my-key", "workers", new redis.clients.jedis.StreamEntryID("0-0"));
  System.out.println(result);
}
```

--------------------------------

### ioredis HELLO example

Source: https://upstash.com/docs/redis/commands/connection/hello

Example using the ioredis client. It creates a client from REDIS_URL and calls the hello() method, logging the result.

```javascript
import Redis from "ioredis";const redis = new Redis(process.env.REDIS_URL!);const result = await redis.hello();console.log(result);
```

--------------------------------

### Redis CLI TTL example

Source: https://upstash.com/docs/redis/commands/generic/ttl

Example using the Redis CLI to get the TTL of the key 'my-key'.

```redis
TTL my-key
```

--------------------------------

### upstash_redis GET example

Source: https://upstash.com/docs/redis/commands/string/get

Example using the upstash_redis Python SDK. It reads the value of 'my-key' and prints the result.

```python
from upstash_redis import Redis
redis = Redis.from_env()
result = redis.get("my-key")
print(result)
```

--------------------------------

### XACK example with Redis CLI

Source: https://upstash.com/docs/redis/commands/streams/xack

Example of using XACK with the Redis CLI.

```bash
XACK my-key workers 0-0
```

--------------------------------

### XACK example with go-redis

Source: https://upstash.com/docs/redis/commands/streams/xack

Example of using XACK with the go-redis client.

```go
package main

import (
    "context"
    "fmt"
    "os"
    "github.com/redis/go-redis/v9"
)

func main() {
    opts, err := redis.ParseURL(os.Getenv("REDIS_URL"))
    if err != nil {
        panic(err)
    }
    client := redis.NewClient(opts)
    result, err := client.XAck(context.Background(), "my-key", "workers", "0-0").Result()
    if err != nil {
        panic(err)
    }
    fmt.Println(result)
}
```

--------------------------------

### JSON.ARRLEN CLI example

Source: https://upstash.com/docs/redis/commands/json/json-arrlen

Example using the Redis CLI to get the length of the array at $.tags in the profile key.

```text
JSON.ARRLEN profile $.tags
```

--------------------------------

### PFCOUNT Example with Redis CLI

Source: https://upstash.com/docs/redis/commands/hyperloglog/pfcount

Example of using PFCOUNT with the Redis CLI to get the cardinality of a single key.

```bash
PFCOUNT my-key
```

--------------------------------

### Run the app

Source: https://upstash.com/docs/redis/tutorials/cloud_run_sessions

Starts the Node.js application.

```bash
node index.js
```

--------------------------------

### upstash_redis hrandfield example

Source: https://upstash.com/docs/redis/commands/hash/hrandfield

Example using the upstash_redis Python client to get a random field from a hash with hrandfield.

```python
from upstash_redis import Redis
redis = Redis.from_env()
result = redis.hrandfield("my-key")
print(result)
```

--------------------------------

### go-redis example

Source: https://upstash.com/docs/redis/commands/server/config-get

Example using the go-redis client to call ConfigGet for 'notify-keyspace-events'.

```go
package main

import (
    "context"
    "fmt"
    "os"
    "github.com/redis/go-redis/v9"
)

func main() {
    opts, err := redis.ParseURL(os.Getenv("REDIS_URL"))
    if err != nil {
        panic(err)
    }
    client := redis.NewClient(opts)
    result, err := client.ConfigGet(context.Background(), "notify-keyspace-events").Result()
    if err != nil {
        panic(err)
    }
    fmt.Println(result)
}
```

--------------------------------

### Initialize Node project and install ioredis

Source: https://upstash.com/docs/redis/tutorials/aws_app_runner_with_redis

Initializes a new Node.js project and installs the ioredis client library, which is required for connecting to Redis.

```bash
npm initnpm install ioredis
```

--------------------------------

### HPEXPIREAT go-redis example

Source: https://upstash.com/docs/redis/commands/hash/hpexpireat

Example of using HPEXPIREAT with the go-redis client, including connection setup and error handling.

```go
package main

import (
    "context"
    "fmt"
    "os"
    "github.com/redis/go-redis/v9"
)

func main() {
    opts, err := redis.ParseURL(os.Getenv("REDIS_URL"))
    if err != nil {
        panic(err)
    }
    client := redis.NewClient(opts)
    result, err := client.HPExpireAt(context.Background(), "my-key", time.UnixMilli(1735689600), "field").Result()
    if err != nil {
        panic(err)
    }
    fmt.Println(result)
}
```

--------------------------------

### HPEXPIREAT node-redis example

Source: https://upstash.com/docs/redis/commands/hash/hpexpireat

Example of using HPEXPIREAT with the node-redis client, including connection setup and error handling.

```javascript
import { createClient } from "redis";const client = await createClient({ url: process.env.REDIS_URL })  .on("error", console.error)  .connect();const result = await client.hpExpireAt("my-key", "field", 1735689600);console.log(result);
```

--------------------------------

### go-redis SUNIONSTORE Example

Source: https://upstash.com/docs/redis/commands/set/sunionstore

Example using the go-redis client. It connects to Redis, stores the union of the specified keys, and prints the result.

```go
package main

import (
    "context"
    "fmt"
    "os"
    "github.com/redis/go-redis/v9"
)

func main() {
    opts, err := redis.ParseURL(os.Getenv("REDIS_URL"))
    if err != nil {
        panic(err)
    }
    client := redis.NewClient(opts)
    result, err := client.SUnionStore(context.Background(), "destination-key", "my-key").Result()
    if err != nil {
        panic(err)
    }
    fmt.Println(result)
}
```

--------------------------------

### go-redis SUNIONCARD example

Source: https://upstash.com/docs/redis/commands/set/sunioncard

go-redis client example for SUNIONCARD. It parses REDIS_URL, creates a client, and calls SUnionCard with a nil limit.

```go
package mainimport (    "context"    "fmt"    "os"    "github.com/redis/go-redis/v9")func main() {    opts, err := redis.ParseURL(os.Getenv("REDIS_URL"))    if err != nil {        panic(err)    }    client := redis.NewClient(opts)    defer client.Close()    result, err := client.SUnionCard(context.Background(), nil, "set1", "set2").Result()    if err != nil {        panic(err)    }    fmt.Println(result)}
```

--------------------------------

### GET <key>

Source: https://upstash.com/docs/redis/commands/string/get

Documentation for the Redis GET command, including syntax, arguments, response, and examples in multiple client libraries.

```APIDOC
## GET <key>

### Description
Reads the string value stored at a key. Returns null if the key does not exist, and an error if the key holds a value of another type.

### Method
GET

### Endpoint
GET <key>

### Parameters
#### Path Parameters
- `<key>` (string) - Required - Redis key targeted by the command.

### Response
#### Success Response
- **RESP2**: Bulk string or Null bulk string or null array
- **RESP3**: Bulk string or Null

#### Response Example
```
GET my-key
```

### Examples
#### Redis CLI
```
GET my-key
```

#### @upstash/redis
```typescript
import { Redis } from "@upstash/redis";
const redis = Redis.fromEnv();
type MyType = {
    a: number;
    b: string;
}
const value = await redis.get<MyType>("key");
if (!value) {
    // key doesn't exist
} else {
    // value is of type MyType
}
```

#### upstash_redis
```python
from upstash_redis import Redis
redis = Redis.from_env()
result = redis.get("my-key")
print(result)
```

#### ioredis
```javascript
import Redis from "ioredis";
const redis = new Redis(process.env.REDIS_URL!);
const result = await redis.get("my-key");
console.log(result);
```

#### node-redis
```javascript
import { createClient } from "redis";
const client = await createClient({ url: process.env.REDIS_URL })
  .on("error", console.error)
  .connect();
const result = await client.get("my-key");
console.log(result);
```

#### redis-py
```python
import os
import redis
client = redis.from_url(os.environ["REDIS_URL"])
result = client.get("my-key")
print(result)
```

#### go-redis
```go
package main

import (
    "context"
    "fmt"
    "os"
    "github.com/redis/go-redis/v9"
)

func main() {
    opts, err := redis.ParseURL(os.Getenv("REDIS_URL"))
    if err != nil {
        panic(err)
    }
    client := redis.NewClient(opts)
    result, err := client.Get(context.Background(), "my-key").Result()
    if err != nil {
        panic(err)
    }
    fmt.Println(result)
}
```

#### jedis
```java
import java.net.URI;
import redis.clients.jedis.Jedis;
try (Jedis jedis = new Jedis(new URI(System.getenv("REDIS_URL")))) {
  Object result = jedis.get("my-key");
  System.out.println(result);
}
```

#### redis-rs
```rust
use redis::TypedCommands;
fn main() -> redis::RedisResult<()> {
    let url = std::env::var("REDIS_URL").expect("REDIS_URL is not set");
    let client = redis::Client::open(url)?;
    let mut connection = client.get_connection()?;
    let result = connection.get("my-key")?;
    println!("{result:?}");
    Ok(())
}
```
```

--------------------------------

### go-redis FlushDB example

Source: https://upstash.com/docs/redis/commands/server/flushdb

Example using the go-redis client. Parses REDIS_URL, creates a client, and calls FlushDB.

```go
package main

import (
    "context"
    "fmt"
    "os"
    "github.com/redis/go-redis/v9"
)

func main() {
    opts, err := redis.ParseURL(os.Getenv("REDIS_URL"))
    if err != nil {
        panic(err)
    }
    client := redis.NewClient(opts)
    result, err := client.FlushDB(context.Background()).Result()
    if err != nil {
        panic(err)
    }
    fmt.Println(result)
}
```

--------------------------------

### go-redis SMISMEMBER example

Source: https://upstash.com/docs/redis/commands/set/smismember

Example using the go-redis client. Parses the REDIS_URL environment variable, creates a client, and checks membership for a single member.

```go
package mainimport (    "context"    "fmt"    "os"    "github.com/redis/go-redis/v9")func main() {    opts, err := redis.ParseURL(os.Getenv("REDIS_URL"))    if err != nil {        panic(err)    }    client := redis.NewClient(opts)    result, err := client.SMIsMember(context.Background(), "my-key", "member").Result()    if err != nil {        panic(err)    }    fmt.Println(result)}
```

--------------------------------

### ZRANK Example with Redis CLI

Source: https://upstash.com/docs/redis/commands/sorted-set/zrank

Example of using ZRANK with the Redis CLI to get the rank of a member in a sorted set.

```bash
ZRANK my-key member
```

--------------------------------

### HEXPIRETIME example with Redis CLI

Source: https://upstash.com/docs/redis/commands/hash/hexpiretime

Example of using HEXPIRETIME with the Redis CLI to get the expiration time of a single field.

```bash
HEXPIRETIME my-key FIELDS 1 field
```

--------------------------------

### go-redis example

Source: https://upstash.com/docs/redis/commands/connection/client-setinfo

Example using the go-redis client to send CLIENT SETINFO with LIB-NAME 'my-client'. Uses the REDIS_URL environment variable.

```go
package main

import (
    "context"
    "fmt"
    "os"
    "github.com/redis/go-redis/v9"
)

func main() {
    opts, err := redis.ParseURL(os.Getenv("REDIS_URL"))
    if err != nil {
        panic(err)
    }
    client := redis.NewClient(opts)
    result, err := client.Do(context.Background(), "CLIENT", "SETINFO", "LIB-NAME", "my-client").Result()
    if err != nil {
        panic(err)
    }
    fmt.Println(result)
}
```

--------------------------------

### RESET example with go-redis

Source: https://upstash.com/docs/redis/commands/connection/reset

Example of using the RESET command with the go-redis client library.

```go
package main

import (
    "context"
    "fmt"
    "os"
    "github.com/redis/go-redis/v9"
)

func main() {
    opts, err := redis.ParseURL(os.Getenv("REDIS_URL"))
    if err != nil {
        panic(err)
    }
    client := redis.NewClient(opts)
    result, err := client.Do(context.Background(), "RESET").Result()
    if err != nil {
        panic(err)
    }
    fmt.Println(result)
}
```

--------------------------------

### CONFIG GET

Source: https://upstash.com/docs/redis/commands/server/config-get

Documentation for the CONFIG GET command, including syntax, arguments, response formats, and examples in multiple client libraries.

```APIDOC
## CONFIG GET

### Description
Reads runtime configuration parameters. Parameter names may contain glob-style patterns, so one call can fetch a family of settings. The reply is a map of names to values under RESP3, and the same pairs as a flat array under RESP2.

### Method
GET

### Endpoint
CONFIG GET <parameter> [parameter ...]

### Parameters
#### Arguments
- **parameter** (string) - Required - One or more glob-style configuration parameter patterns.

### Response
#### Success Response
- RESP2: Flat array of alternating configuration names and values
- RESP3: Map of configuration names to values

### Examples
#### Redis CLI
```
CONFIG GET notify-keyspace-events
```

#### ioredis
```
import Redis from "ioredis";
const redis = new Redis(process.env.REDIS_URL!);
const result = await redis.config("GET", "notify-keyspace-events");
console.log(result);
```

#### node-redis
```
import { createClient } from "redis";
const client = await createClient({ url: process.env.REDIS_URL })
  .on("error", console.error)
  .connect();
const result = await client.configGet("notify-keyspace-events");
console.log(result);
```

#### redis-py
```
import os
import redis
client = redis.from_url(os.environ["REDIS_URL"])
result = client.config_get("notify-keyspace-events")
print(result)
```

#### go-redis
```
package main

import (
    "context"
    "fmt"
    "os"
    "github.com/redis/go-redis/v9"
)

func main() {
    opts, err := redis.ParseURL(os.Getenv("REDIS_URL"))
    if err != nil {
        panic(err)
    }
    client := redis.NewClient(opts)
    result, err := client.ConfigGet(context.Background(), "notify-keyspace-events").Result()
    if err != nil {
        panic(err)
    }
    fmt.Println(result)
}
```

#### jedis
```
import java.net.URI;
import redis.clients.jedis.Jedis;
try (Jedis jedis = new Jedis(new URI(System.getenv("REDIS_URL")))) {
  Object result = jedis.configGet("notify-keyspace-events");
  System.out.println(result);
}
```

#### redis-rs
```
fn main() -> redis::RedisResult<()> {
    let url = std::env::var("REDIS_URL").expect("REDIS_URL is not set");
    let client = redis::Client::open(url)?;
    let mut connection = client.get_connection()?;
    let mut command = redis::cmd("CONFIG");
    command.arg("GET");
    command.arg("notify-keyspace-events");
    let result: redis::Value = command.query(&mut connection)?;
    println!("{result:?}");
    Ok(())
}
```
```

--------------------------------

### go-redis example for JSON.OBJLEN

Source: https://upstash.com/docs/redis/commands/json/json-objlen

Example using the go-redis client. It parses REDIS_URL, creates a client, and calls JSONObjLen with a context, key, and path.

```go
package main

import (
    "context"
    "fmt"
    "os"
    "github.com/redis/go-redis/v9"
)

func main() {
    opts, err := redis.ParseURL(os.Getenv("REDIS_URL"))
    if err != nil {
        panic(err)
    }
    client := redis.NewClient(opts)
    result, err := client.JSONObjLen(context.Background(), "profile", "$").Result()
    if err != nil {
        panic(err)
    }
    fmt.Println(result)
}
```

--------------------------------

### node-redis GET example

Source: https://upstash.com/docs/redis/commands/string/get

Example using the node-redis client. It creates a client with the REDIS_URL environment variable, connects, and reads 'my-key'.

```typescript
import { createClient } from "redis";
const client = await createClient({ url: process.env.REDIS_URL })
  .on("error", console.error)
  .connect();
const result = await client.get("my-key");
console.log(result);
```

--------------------------------

### MSETNX with go-redis

Source: https://upstash.com/docs/redis/commands/string/msetnx

Example using the go-redis client. It parses the REDIS_URL, creates a client, calls MSetNX, and prints the result.

```go
package main

import (
    "context"
    "fmt"
    "os"
    "github.com/redis/go-redis/v9"
)

func main() {
    opts, err := redis.ParseURL(os.Getenv("REDIS_URL"))
    if err != nil {
        panic(err)
    }
    client := redis.NewClient(opts)
    result, err := client.MSetNX(context.Background(), "my-key", "value").Result()
    if err != nil {
        panic(err)
    }
    fmt.Println(result)
}
```

--------------------------------

### LINDEX example with Redis CLI

Source: https://upstash.com/docs/redis/commands/list/lindex

Example of using LINDEX with the Redis CLI to get the element at index 0 of the list 'my-key'.

```bash
LINDEX my-key 0
```

--------------------------------

### Redis CLI JSON.TYPE example

Source: https://upstash.com/docs/redis/commands/json/json-type

Example using the Redis CLI to get the type of the value at path $.name in the profile key.

```bash
JSON.TYPE profile $.name
```

--------------------------------

### go-redis VECTOR.INFO example

Source: https://upstash.com/docs/redis/commands/vector/vector-info

Client example using go-redis v9. It parses REDIS_URL, connects, executes the command, and prints the result.

```go
package main
import (    "context"    "fmt"    "os"    "github.com/redis/go-redis/v9")
func main() {    opts, err := redis.ParseURL(os.Getenv("REDIS_URL"))    if err != nil {        panic(err)    }    client := redis.NewClient(opts)    result, err := client.Do(context.Background(), "VECTOR.INFO", "my-index").Result()    if err != nil {        panic(err)    }    fmt.Println(result)}
```

--------------------------------

### Redis CLI JSON.STRLEN example

Source: https://upstash.com/docs/redis/commands/json/json-strlen

Example of using JSON.STRLEN with the Redis CLI. It gets the length of the string at $.name in the profile key.

```bash
JSON.STRLEN profile $.name
```

--------------------------------

### Redis CLI HRANDFIELD example

Source: https://upstash.com/docs/redis/commands/hash/hrandfield

Example of using HRANDFIELD in the Redis CLI to get a random field from the hash stored at my-key.

```bash
HRANDFIELD my-key
```

--------------------------------

### CLIENT LIST example with ioredis

Source: https://upstash.com/docs/redis/commands/connection/client-list

Use ioredis to call CLIENT LIST. Requires REDIS_URL environment variable.

```javascript
import Redis from "ioredis";
const redis = new Redis(process.env.REDIS_URL!);
const result = await redis.client("LIST");
console.log(result);
```

--------------------------------

### Python examples for $should

Source: https://upstash.com/docs/redis/search/query-operators/boolean-operators/should

Python examples using products.query with $should in three scenarios: as OR, as optional booster, and with multiple boosters.

```python
# Match either conditionproducts.query(filter={"$should": [{"category": "electronics"}, {"category": "sports"}]})# Optional boost: "wireless" is required, "premium" boosts score if presentproducts.query(filter={"$must": {"name": "wireless"}, "$should": {"description": "premium"}})# Multiple optional boostersproducts.query(filter={
    "$must": {"category": "electronics"},
    "$should": [
        {"name": "wireless"},
        {"description": "bluetooth"},
        {"description": "premium"},
    ],
})
```

--------------------------------

### redis-rs example

Source: https://upstash.com/docs/redis/commands/sorted-set/zrevrange

Example using the redis-rs Rust client. It opens a connection from REDIS_URL and calls zrevrange with start 0 and stop -1.

```rust
use redis::TypedCommands;

fn main() -> redis::RedisResult<()> {
    let url = std::env::var("REDIS_URL").expect("REDIS_URL is not set");
    let client = redis::Client::open(url)?;
    let mut connection = client.get_connection()?;
    let result = connection.zrevrange("my-key", 0, -1)?;
    println!("{result:?}");
    Ok(())
}
```

--------------------------------

### BLPOP jedis Example

Source: https://upstash.com/docs/redis/commands/list/blpop

Example using the jedis client to call blpop with timeout 1.5 and key 'my-key'.

```java
import java.net.URI;
import redis.clients.jedis.Jedis;

try (Jedis jedis = new Jedis(new URI(System.getenv("REDIS_URL")))) {
  Object result = jedis.blpop(1.5, "my-key");
  System.out.println(result);
}
```

--------------------------------

### Redis CLI KEYS example

Source: https://upstash.com/docs/redis/commands/generic/keys

Example using the Redis CLI to list all keys in the database.

```bash
KEYS *
```

--------------------------------

### JSON.RESP Example with Redis CLI

Source: https://upstash.com/docs/redis/commands/json/json-resp

Example of using JSON.RESP with the Redis CLI to get the RESP form of the 'profile' document at the root path.

```redis
JSON.RESP profile $
```

--------------------------------

### go-redis example

Source: https://upstash.com/docs/redis/commands/sorted-set/zincrby

Example using the go-redis client. It parses the REDIS_URL, creates a client, increments the score of 'member' by 1 in 'my-key', and prints the result.

```go
package main

import (
    "context"
    "fmt"
    "os"
    "github.com/redis/go-redis/v9"
)

func main() {
    opts, err := redis.ParseURL(os.Getenv("REDIS_URL"))
    if err != nil {
        panic(err)
    }
    client := redis.NewClient(opts)
    result, err := client.ZIncrBy(context.Background(), "my-key", 1, "member").Result()
    if err != nil {
        panic(err)
    }
    fmt.Println(result)
}
```

--------------------------------

### ioredis transaction example

Source: https://upstash.com/docs/redis/commands/transactions/multi

ioredis example that starts a transaction with multi(), queues a SET command, and executes it with exec(). Uses the REDIS_URL environment variable.

```javascript
import Redis from "ioredis";const client = new Redis(process.env.REDIS_URL!);const result = await client.multi().set("balance", "100").exec();
```

--------------------------------

### go-redis DBSIZE example

Source: https://upstash.com/docs/redis/commands/server/dbsize

Example of using the go-redis SDK to call DBSIZE. It parses the REDIS_URL environment variable, creates a client, and prints the result.

```go
package main

import (
    "context"
    "fmt"
    "os"
    "github.com/redis/go-redis/v9"
)

func main() {
    opts, err := redis.ParseURL(os.Getenv("REDIS_URL"))
    if err != nil {
        panic(err)
    }
    client := redis.NewClient(opts)
    result, err := client.DBSize(context.Background()).Result()
    if err != nil {
        panic(err)
    }
    fmt.Println(result)
}
```

--------------------------------

### Create Serverless project and install Bull

Source: https://upstash.com/docs/redis/tutorials/job_processing

These commands create a new Serverless project for the producer and install the Bull queue library. The serverless command output shows the prompts and responses that create the producer project. Run npm install bull to add Bull as a dependency.

```bash
➜  serverlessServerless: No project detected. Do you want to create a new one? YesServerless: What do you want to make? AWS Node.jsServerless: What do you want to call this project? producerProject successfully created in 'producer' folder.You can monitor, troubleshoot, and test your new service with a free Serverless account.Serverless: Would you like to enable this? NoYou can run the “serverless” command again if you change your mind later.
```

```bash
npm install bull
```

--------------------------------

### Jedis example

Source: https://upstash.com/docs/redis/commands/sorted-set/zrevrange

Example using the Jedis Java client. It creates a Jedis instance from REDIS_URL and calls zrevrange with start 0 and stop -1.

```java
import java.net.URI;
import redis.clients.jedis.Jedis;

try (Jedis jedis = new Jedis(new URI(System.getenv("REDIS_URL")))) {
  Object result = jedis.zrevrange("my-key", 0, -1);
  System.out.println(result);
}
```

--------------------------------

### @upstash/redis TYPE example

Source: https://upstash.com/docs/redis/commands/generic/type

Example using the @upstash/redis SDK. It sets a key and then calls redis.type() to get its type, logging "string".

```typescript
import { Redis } from "@upstash/redis";
const redis = Redis.fromEnv();
await redis.set("key", "value");
const t = await redis.type("key");
console.log(t) // "string"
```

--------------------------------

### ZSCORE with redis-rs

Source: https://upstash.com/docs/redis/commands/sorted-set/zscore

Example using the redis-rs client to get a score.

```rust
use redis::TypedCommands;

fn main() -> redis::RedisResult<()> {
    let url = std::env::var("REDIS_URL").expect("REDIS_URL is not set");
    let client = redis::Client::open(url)?;
    let mut connection = client.get_connection()?;
    let result = connection.zscore("my-key", "member")?;
    println!("{result:?}");
    Ok(())
}
```

--------------------------------

### redis-rs HELLO example

Source: https://upstash.com/docs/redis/commands/connection/hello

Example using the redis-rs client. It opens a connection from REDIS_URL, sends the HELLO command, and prints the result.

```rust
fn main() -> redis::RedisResult<()> {    let url = std::env::var("REDIS_URL").expect("REDIS_URL is not set");    let client = redis::Client::open(url)?;    let mut connection = client.get_connection()?;    let mut command = redis::cmd("HELLO");    let result: redis::Value = command.query(&mut connection)?;    println!("{result:?}");    Ok(())}
```

--------------------------------

### ZSCORE with jedis

Source: https://upstash.com/docs/redis/commands/sorted-set/zscore

Example using the jedis client to get a score.

```java
import java.net.URI;
import redis.clients.jedis.Jedis;

try (Jedis jedis = new Jedis(new URI(System.getenv("REDIS_URL")))) {
  Object result = jedis.zscore("my-key", "member");
  System.out.println(result);
}
```

--------------------------------

### XPENDING with go-redis

Source: https://upstash.com/docs/redis/commands/streams/xpending

Example using the go-redis client to call XPENDING.

```go
package main

import (
    "context"
    "fmt"
    "os"
    "github.com/redis/go-redis/v9"
)

func main() {
    opts, err := redis.ParseURL(os.Getenv("REDIS_URL"))
    if err != nil {
        panic(err)
    }
    client := redis.NewClient(opts)
    result, err := client.XPending(context.Background(), "my-key", "workers").Result()
    if err != nil {
        panic(err)
    }
    fmt.Println(result)
}
```

--------------------------------

### ZSCORE with go-redis

Source: https://upstash.com/docs/redis/commands/sorted-set/zscore

Example using the go-redis client to get a score.

```go
package main

import (
    "context"
    "fmt"
    "os"
    "github.com/redis/go-redis/v9"
)

func main() {
    opts, err := redis.ParseURL(os.Getenv("REDIS_URL"))
    if err != nil {
        panic(err)
    }
    client := redis.NewClient(opts)
    result, err := client.ZScore(context.Background(), "my-key", "member").Result()
    if err != nil {
        panic(err)
    }
    fmt.Println(result)
}
```

--------------------------------

### TOUCH Example with go-redis

Source: https://upstash.com/docs/redis/commands/generic/touch

Example of using TOUCH with the go-redis client, touching a single key and printing the result.

```go
package main

import (
    "context"
    "fmt"
    "os"
    "github.com/redis/go-redis/v9"
)

func main() {
    opts, err := redis.ParseURL(os.Getenv("REDIS_URL"))
    if err != nil {
        panic(err)
    }
    client := redis.NewClient(opts)
    result, err := client.Touch(context.Background(), "my-key").Result()
    if err != nil {
        panic(err)
    }
    fmt.Println(result)
}
```

--------------------------------

### Initialize Fastly Compute project with fastly compute init

Source: https://upstash.com/docs/redis/quickstarts/fastlycompute

Initializes a new Fastly Compute project. Select option 2 for JavaScript and option 2 for the Empty starter for JavaScript.

```bash
> fastly compute initCreating a new Compute project.Press ^C at any time to quit.Name: [fastly-upstash]Description:Author: [enes@upstash.com]Language:[1] Rust[2] JavaScript[3] Go[4] Other ('bring your own' Wasm binary)Choose option: [1] 2Starter kit:[1] Default starter for JavaScript    A basic starter kit that demonstrates routing, simple synthetic responses and    overriding caching rules.    https://github.com/fastly/compute-starter-kit-javascript-default[2] Empty starter for JavaScript    An empty application template for the Fastly Compute environment which simply    returns a 200 OK response.    https://github.com/fastly/compute-starter-kit-javascript-emptyChoose option or paste git URL: [1] 2
```

--------------------------------

### ZSCORE with redis-py

Source: https://upstash.com/docs/redis/commands/sorted-set/zscore

Example using the redis-py client to get a score.

```python
import os
import redis
client = redis.from_url(os.environ["REDIS_URL"])
result = client.zscore("my-key", "member")
print(result)
```
Tokens:
Raw