> ## Documentation Index
> Fetch the complete documentation index at: https://upstash.com/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# EXPIRE

> Set a key's TTL in seconds.

Use `EXPIRE` to give a key a lifetime in seconds, after which the key is deleted automatically.

Whether the expiration survives later writes depends on the command: replacing the value with [`SET`](/docs/redis/commands/string/set) clears it, while commands that modify a value in place, such as [`INCR`](/docs/redis/commands/string/incr), [`LPUSH`](/docs/redis/commands/list/lpush) or [`HSET`](/docs/redis/commands/hash/hset), leave it untouched. A negative lifetime deletes the key immediately.

The optional condition decides when the new expiration is applied: `NX` only when the key currently has none, `XX` only when it already has one, `GT` only when the new expiration is later than the current one, and `LT` only when it is earlier. Since a key without an expiration counts as living forever, `GT` never adds one and `LT` always does. The reply is `1` when the expiration was set and `0` when the key does not exist or the condition was not met.

Read the remaining lifetime with [`TTL`](/docs/redis/commands/generic/ttl) and remove it again with [`PERSIST`](/docs/redis/commands/generic/persist).

## Syntax

```redis theme={"system"}
EXPIRE <key> <seconds> [NX | XX | GT | LT]
```

## Arguments

| Argument | Required | Repeatable | Description |
| - | - | - | - |
| `<key>` | Yes | No | Redis key targeted by the command. |
| `<seconds>` | Yes | No | Lifetime in seconds. |
| `(NX \| XX \| GT \| LT)` | No | No | Choose one form: `NX` (only when the key has no expiration); `XX` (only when the key already has one); `GT` (only when the new expiration is later than the current one); `LT` (only when it is earlier). |

## Important points

* `NX` cannot be combined with `XX`, `GT`, or `LT`, and `GT` and `LT` cannot be used together.
* A key with no expiration counts as an infinite one, so `GT` never sets an expiration on such a key and `LT` always does.

## 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 | Integer: `1` if the timeout was set, `0` otherwise |
| RESP3 | Integer: `1` if the timeout was set, `0` otherwise |

> [!NOTE]
>
> Client libraries often decode bulk strings, maps, sets, and numeric strings into language-native values. The table describes the Redis wire reply.

## Examples

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

> **Redis CLI**
>
> ```bash theme={"system"}
> EXPIRE my-key 1000
> ```

> **@upstash/redis**
>
> ```ts theme={"system"}
> import { Redis } from "@upstash/redis";
>
> const redis = Redis.fromEnv();
>
> await redis.set("mykey", "Hello");
> await redis.expire("mykey", 10);
> ```

> **upstash\_redis**
>
> ```python theme={"system"}
> from upstash_redis import Redis
>
> redis = Redis.from_env()
> result = redis.expire("my-key", 1000)
> print(result)
> ```

> **ioredis**
>
> ```ts theme={"system"}
> import Redis from "ioredis";
>
> const redis = new Redis(process.env.REDIS_URL!);
> const result = await redis.expire("my-key", "1000");
> console.log(result);
> ```

> **node-redis**
>
> ```ts theme={"system"}
> import { createClient } from "redis";
>
> const client = await createClient({ url: process.env.REDIS_URL })
>   .on("error", console.error)
>   .connect();
> const result = await client.expire("my-key", 1000);
> console.log(result);
> ```

> **redis-py**
>
> ```python theme={"system"}
> import os
> import redis
>
> client = redis.from_url(os.environ["REDIS_URL"])
> result = client.expire("my-key", 1000)
> print(result)
> ```

> **go-redis**
>
> ```go theme={"system"}
> package main
>
> import (
>     "context"
>     "fmt"
>     "os"
>     "time"
>
>     "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.Expire(context.Background(), "my-key", 1000*time.Second).Result()
>     if err != nil {
>         panic(err)
>     }
>     fmt.Println(result)
> }
> ```

> **jedis**
>
> ```java theme={"system"}
> import java.net.URI;
>
> import redis.clients.jedis.Jedis;
>
> try (Jedis jedis = new Jedis(new URI(System.getenv("REDIS_URL")))) {
>   Object result = jedis.expire("my-key", 1000);
>   System.out.println(result);
> }
> ```

> **redis-rs**
>
> ```rust theme={"system"}
> 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.expire("my-key", 1000)?;
>     println!("{result:?}");
>     Ok(())
> }
> ```


## Related topics

- [EXPIRE](/docs/redis/sdks/ts/commands/generic/expire.md)
- [EXPIREAT](/docs/redis/commands/generic/expireat.md)
- [EXPIRETIME](/docs/redis/commands/generic/expiretime.md)


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.