# Manage Topics

> For the complete documentation index, see [llms.txt](https://docs.redpanda.com/llms.txt). Component-specific: [streaming-full.txt](https://docs.redpanda.com/streaming-full.txt)

---
title: Manage Topics
latest-operator-version: v26.1.4
# EOL = End-of-Life (support lifecycle status)
page-is-nearing-eol: "false"
page-is-past-eol: "true"
page-eol-date: December 22, 2024
latest-console-tag: v3.7.3
latest-connect-version: 4.93.0
docname: config-topics
page-component-name: streaming
page-version: "23.3"
page-component-version: "23.3"
page-component-title: Streaming
page-relative-src-path: config-topics.adoc
page-edit-url: https://github.com/redpanda-data/docs/edit/v/23.3/modules/develop/pages/config-topics.adoc
description: Learn how to create topics, update topic configurations, and delete topics or records.
page-git-created-date: "2023-07-24"
page-git-modified-date: "2024-02-26"
support-status: past end-of-life
---

<!-- Source: https://docs.redpanda.com/streaming/23.3/develop/config-topics.md -->

Topics provide a way to organize events in a data streaming platform. When you create a topic, the default cluster-wide topic configurations are applied using the cluster configuration file, unless you specify a different configuration for specific topics when you create them.

The following table shows the default cluster-wide topic configurations and the equivalent topic property names:

| Cluster property | Default | Topic property |
| --- | --- | --- |
| log_cleanup_policy | delete | cleanup.policy |
| retention_bytes | null (no limit) | retention.bytes |
| log_retention_ms | 604800000 ms (1 week) | retention.ms |
| log_segment_ms | null (no limit) | segment.ms |
| log_segment_size | 134217728 bytes (128 MiB) | segment.bytes |
| log_compression_type | producer | compression.type |
| log_message_timestamp_type | CreateTime | message.timestamp.type |
| kafka_batch_max_bytes | 1048576 bytes (1 MiB) | max.message.bytes |

These default settings are best suited to a one-broker cluster in a development environment. To learn how to modify the default cluster-wide configurations, see [Configure Cluster Properties](https://docs.redpanda.com/streaming/23.3/manage/cluster-maintenance/cluster-property-configuration/). Even if you set default values that work for most topics, you may still want to change some properties for a specific topic.

> 📝 **NOTE**
>
> For details about topic properties, refer to [Topic Configuration Properties](https://docs.redpanda.com/streaming/23.3/reference/topic-properties/).

## [](#create-a-topic)Create a topic

Creating a topic can be as simple as specifying a name for your topic on the command line. For example, to create a topic named `xyz`:

```bash
rpk topic create xyz
```

This command creates a topic named `xyz` with one partition and one replica, since these are the default values set in the cluster configuration file.

But suppose you want to create a topic with different values for these settings. The guidelines in this section show you how to choose the number of partitions and replicas for your use case.

### [](#choose-the-number-of-partitions)Choose the number of partitions

A partition acts as a log file where topic data is written. Dividing topics into partitions allows producers to write messages in parallel and consumers to read messages in parallel. The higher the number of partitions, the greater the throughput.

> 💡 **TIP**
>
> As a general rule, select a number of partitions that corresponds to the maximum number of consumers in any consumer group that will consume the data.

For example, suppose you plan to create a consumer group with 10 consumers. To create topic `xyz` with 10 partitions:

```bash
rpk topic create xyz -p 10
```

### [](#choose-the-replication-factor)Choose the replication factor

Replicas are copies of partitions that are distributed across different brokers, so if one broker goes down, other brokers still have a copy of the data. The default replication factor in the cluster configuration is set to 1.

By choosing a replication factor greater than 1, you ensure that each partition has a copy of its data on at least one other broker. One replica acts as the leader, and the other replicas are followers.

To specify a replication factor of 3 for topic “xyz”:

```bash
rpk topic create xyz -r 3
```

> 📝 **NOTE**
>
> The replication factor must be an odd number. Redpanda Data recommends a replication factor of 3 for most use cases. Administrators may set a minimum required replication factor for any new topic in the cluster through the cluster-level [`minimum_topic_replication`](https://docs.redpanda.com/streaming/23.3/reference/cluster-properties/#minimum_topic_replication) property.

## [](#update-topic-configurations)Update topic configurations

After you create a topic, you can update the topic property settings for all new data written to it. For example, you can add partitions, change the replication factor, or change a configuration setting like the cleanup policy.

### [](#add-partitions)Add partitions

You can assign a certain number of partitions when you create a topic, and add partitions later. For example, suppose you add brokers to your cluster, and you want to take advantage of the additional processing power. To increase the number of partitions for existing topics, run:

```bash
rpk topic add-partitions [TOPICS...] --num [#]
```

Note that `--num <#>` is the number of partitions to _add_, not the total number of partitions.

### [](#change-the-replication-factor)Change the replication factor

Suppose you create a topic with the default replication factor of 1 (which is specified in the cluster properties configuration file). Now you want to change the replication factor to 3, so you can have two backups of topic data in case a broker goes down. To set the replication factor to 3, run:

```bash
rpk topic alter-config [TOPICS...] --set replication.factor=3
```

> 📝 **NOTE**
>
> The replication factor can’t exceed the number of Redpanda brokers. If you try to set a replication factor greater than the number of brokers, the request is rejected.

### [](#change-the-cleanup-policy)Change the cleanup policy

The cleanup policy determines how to clean up the partition log files when they reach a certain size:

-   `delete` deletes data based on age or log size. Topics retain all records until then.

-   `compact` compacts the data by only keeping the latest values for each KEY. For details on compaction in Redpanda, see [Compaction settings](https://docs.redpanda.com/streaming/23.3/manage/cluster-maintenance/compaction-settings/).

-   `compact,delete` combines both methods.


Unlike compacted topics which keep only the most recent message for a given key, topics configured with a delete cleanup policy provide a running history of all changes for those topics.

Suppose you configure a topic using the default cleanup policy `delete`, and you want to change the policy to `compact`. Run the `rpk topic alter-config` command as shown:

```bash
rpk topic alter-config [TOPICS…] —-set cleanup.policy=compact
```

### [](#remove-a-configuration-setting)Remove a configuration setting

You can remove a configuration that overrides the default setting, and the setting will use the default value again. For example, suppose you altered the cleanup policy to use `compact` instead of the default, `delete`. Now you want to return the policy setting to the default. To remove the configuration setting `cleanup.policy=compact`, run `rpk topic alter-config` with the `--delete` flag as shown:

```bash
rpk topic alter-config [TOPICS...] --delete cleanup.policy
```

## [](#list-topic-configuration-settings)List topic configuration settings

To display all the configuration settings for a topic, run:

```bash
rpk topic describe <topic-name> -c
```

The `-c` flag limits the command output to just the topic configurations. This command is useful for checking the default configuration settings before you make any changes, and for verifying changes after you make them.

The following command output displays after running `rpk topic describe test-topic`, where `test-topic` was created with default settings:

```bash
rpk topic describe test_topic
SUMMARY
=======
NAME        test_topic
PARTITIONS  1
REPLICAS    1

CONFIGS
=======
KEY                           VALUE                          SOURCE
cleanup.policy                delete                         DYNAMIC_TOPIC_CONFIG
compression.type              producer                       DEFAULT_CONFIG
max.message.bytes             1048576                        DEFAULT_CONFIG
message.timestamp.type        CreateTime                     DEFAULT_CONFIG
redpanda.datapolicy           function_name:  script_name:   DEFAULT_CONFIG
redpanda.remote.delete        true                           DEFAULT_CONFIG
redpanda.remote.read          false                          DEFAULT_CONFIG
redpanda.remote.write         false                          DEFAULT_CONFIG
retention.bytes               -1                             DEFAULT_CONFIG
retention.local.target.bytes  -1                             DEFAULT_CONFIG
retention.local.target.ms     86400000                       DEFAULT_CONFIG
retention.ms                  604800000                      DEFAULT_CONFIG
segment.bytes                 1073741824                     DEFAULT_CONFIG
```

Now suppose you add two partitions, and increase the number of replicas to 3. The new command output confirms the changes in the `SUMMARY` section:

SUMMARY
=======
NAME        test\_topic
PARTITIONS  3
REPLICAS    3

## [](#delete-a-topic)Delete a topic

To delete a topic, run:

```bash
rpk topic delete <topic-name>
```

When a topic is deleted, its underlying data is deleted, too.

To delete multiple topics at a time, provide a space-separated list. For example, to delete two topics named `topic1` and `topic2`, run:

```bash
rpk topic delete topic1 topic2
```

You can also use the `-r` flag to specify one or more regular expressions; then, any topic names that match the pattern you specify are deleted. For example, to delete topics with names that start with “f” and end with “r”, run:

```bash
rpk topic  delete -r '^f.*' '.*r$'
```

Note that the first regular expression must start with the `^` symbol, and the last expression must end with the `$` symbol. This requirement helps prevent accidental deletions.

## [](#delete-records-from-a-topic)Delete records from a topic

Redpanda lets you delete data from the beginning of a partition up to a specific offset (event). The offset represents the true creation time of the event, not the time when it was stored by Redpanda. Deleting records frees up disk space, which is especially helpful if your producers are pushing more data than you anticipated in your retention plan. Do this when you know that all consumers have read up to that given offset, and the data is no longer needed.

There are different ways to delete records from a topic, including using the [`rpk topic trim-prefix`](https://docs.redpanda.com/streaming/23.3/reference/rpk/rpk-topic/rpk-topic-trim-prefix/) command or using the `DeleteRecords` Kafka API with Kafka clients.

> 📝 **NOTE**
>
> -   To delete records, `cleanup.policy` must be set to `delete` or `compact,delete`.
>
> -   Object storage is deleted asynchronously. After messages are deleted, the partition’s start offset will have advanced, but garbage collection of deleted segments may not be complete.
>
> -   Similar to Kafka, after deleting records, local storage and object storage may still contain data for deleted offsets. (Redpanda does not truncate segments, instead it bumps the start offset then attempts to delete as many whole segments as possible.) Data before the new start offset is not visible to clients but could be read by someone with access to the local disk of a Redpanda node.

## Suggested labs

-   [Stream Stock Market Data from a CSV file Using Node.js](https://docs.redpanda.com/labs/clients/stock-market-activity-nodejs/)
-   [Stream Stock Market Data from a CSV file Using Python](https://docs.redpanda.com/labs/clients/stock-market-activity-python/)
-   [Build a Chat Room Application with Redpanda and Golang](https://docs.redpanda.com/labs/clients/docker-go/)
-   [Build a Chat Room Application with Redpanda and Java](https://docs.redpanda.com/labs/clients/docker-java/)
-   [Build a Chat Room Application with Redpanda and Node.js](https://docs.redpanda.com/labs/clients/docker-nodejs/)
-   [Build a Chat Room Application with Redpanda and Python](https://docs.redpanda.com/labs/clients/docker-python/)
-   [Build a Chat Room Application with Redpanda and Rust](https://docs.redpanda.com/labs/clients/docker-rust/)

See more

[Search all labs](https://docs.redpanda.com/labs)