# MONITOR

> Stream all commands received.

Use `MONITOR` to stream every command the server processes, as it happens, to the current connection.

The connection turns into a continuous feed and stops accepting other commands, so it must be a dedicated one; closing it is how you stop monitoring. Each line carries a timestamp, the client that sent the command, and the command with its arguments.

It is a debugging tool: it shows the traffic of all clients, arguments included, so it can expose sensitive data, and the added work costs the server throughput while it is running. Use it briefly and against non-production data where possible.

## Syntax

```redis
MONITOR
```

## Arguments

This command takes no arguments.

## Important points

- This is a connection-oriented command and is available over native Redis TCP, not the stateless REST endpoint.
- This command can expose administrative information or make a broad destructive change. Restrict it to trusted code paths.
- MONITOR changes the TCP connection into a continuous command stream. Use a dedicated connection and close it to stop monitoring.

## Response

The reply reports the result of the operation. Error replies have the same shape in RESP2 and RESP3 and are surfaced as exceptions by the SDKs below.

| Protocol | Reply |
| --- | --- |
| RESP2 | Simple string `OK`, then a stream of bulk strings, one per command the server executes |
| RESP3 | Simple string `OK`, then a stream of bulk strings, one per command the server executes |

<Note>
  Client libraries often decode bulk strings, maps, sets, and numeric strings into language-native values. The table describes the Redis wire reply.
</Note>

## Examples

TCP examples use the TLS `REDIS_URL` from the Upstash console. REST examples use `UPSTASH_REDIS_REST_URL` and `UPSTASH_REDIS_REST_TOKEN`.

<AccordionGroup>

<Accordion title="Redis CLI" icon="terminal">

```bash
MONITOR
```

</Accordion>

<Accordion title="ioredis" icon="node-js" iconType="brands">

```ts
import Redis from "ioredis";

const redis = new Redis(process.env.REDIS_URL!);
redis.monitor((error, monitor) => {
  if (error) throw error;
  monitor.on("monitor", (time, args, source, database) => {
    console.log({ time, args, source, database });
  });
});
```

</Accordion>

<Accordion title="node-redis" icon="node-js" iconType="brands">

```ts
import { createClient } from "redis";

const client = await createClient({ url: process.env.REDIS_URL })
  .on("error", console.error)
  .connect();

await client.monitor((command) => {
  console.log(command);
});
```

</Accordion>

<Accordion title="redis-py" icon="python" iconType="brands">

```python
import os
import redis

client = redis.from_url(os.environ["REDIS_URL"])
with client.monitor() as monitor:
    for command in monitor.listen():
        print(command)
```

</Accordion>

<Accordion title="jedis" icon="java" iconType="brands">

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

try (Jedis jedis = new Jedis(new URI(System.getenv("REDIS_URL")))) {
  jedis.monitor(new JedisMonitor() {
    @Override
    public void onCommand(String command) {
      System.out.println(command);
    }
  });
}
```

</Accordion>

<Accordion title="redis-rs" icon="rust" iconType="brands">

```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 packed = redis::cmd("MONITOR").get_packed_command();
    connection.send_packed_command(&packed)?;
    loop {
        println!("{:?}", connection.recv_response()?);
    }
}
```

</Accordion>

</AccordionGroup>