Self-hosted service
redpanda-data/console avatar
redpanda-data/console

Redpanda Console: a UI that writes JavaScript into your Kafka message filters

Redpanda Console is a developer-friendly UI for managing your Kafka/Redpanda workloads. Console gives you a simple, interactive approach for gaining visibility into your topics, masking data, managing consumer groups, and exploring real-time data with time-travel debugging.

4,353 stars435 forksTypeScriptLicense varies

At a glance

What is it?
Redpanda Console, formerly Kowl, is a web application for inspecting topics, consumer groups, ACLs and schema registries on any Kafka or Redpanda cluster. Its sharpest feature is also its sharpest constraint: message filtering runs JavaScript you supply, so the console trusts the operator completely.
Who is it for?
Adopt Redpanda Console when your cluster is Kafka v1.0.0 or newer and your operators can be trusted with arbitrary JavaScript in a browser field. If you need role separation between viewers and editors, check the project documentation first, since the README does not describe it.
Can I use it commercially?
Not without permission. GitHub finds no licence file in the repository, and without a licence all rights are reserved by default: you may read the code but not reuse it. Check the README, or ask the authors, before using it.
Is it still maintained?
Yes. The repository received new commits within the last day.
What is it written in?
Mainly TypeScript, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • redpanda-data/console4,353 ★ · +19
Star history
Repository2026-09-232026-11-15
redpanda-data/console4.3k4.4k

19 Stars in the last 53 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

Why a Kafka operator needs a browser console at all

Everything Console does, Kafka already exposes over its protocol. What changes is who sits in front of it. Without a UI, checking a single message means writing a consumer in Go, Python or Java, pointing it at a broker list, and waiting for the partition assignment to land. Console removes that bootstrap cost. It is a single web application that talks to any Kafka or Redpanda deployment compatible with v1.0.0 or later, and it renders the state that cluster metadata holds but nobody surfaces on its own: active consumer groups and their offsets, per-partition low and high water marks, broker rack ids, ACLs and SASL-SCRAM users.

The audience is narrow and specific. Platform engineers who own several clusters, and developers debugging a pipeline that has stopped moving and need the payload, not the aggregate. The project was previously known as Kowl. Console is an operator console. It assumes the person at the keyboard is already trusted against the cluster.

JavaScript filter expressions run against decoded messages

The message viewer is the part worth arguing about. You select a topic, choose a partition and an offset range, and Console fetches records, decodes them and lets you narrow the result with a JavaScript function rather than a fixed query grammar. That is a real difference from a text-match filter. Predicates can inspect nested structure, so a check on a field three levels down is expressible in a way a substring search cannot reach.

Encoding detection is automatic for JSON, Avro, Protobuf, CBOR, XML, MessagePack, text and binary hex view, with Protobuf and CBOR as the two exceptions listed in the README.

Running Console in a container against a cluster on the same host

The quick start assumes Docker and an existing broker. Because the Console container has its own network scope, the bootstrap server has to be the host address rather than loopback:

shell
docker run -p 8080:8080 -e KAFKA_BROKERS=host.docker.internal:9092 docker.redpanda.com/redpandadata/console:latest

Port 8080 is the web UI. The README then draws attention to a detail that is easy to skim past: brokers answer a client's first connection with the address list of every broker, so a bootstrap address that resolves is only half the requirement. The advertised listener has to resolve too, and the README gives the expected shape as PLAINTEXT://host.docker.internal:9092. If your brokers advertise their own hostname or an internal IP, the client connects once and then fails to fetch metadata.

On Linux, the workaround is the host network namespace, which keeps the advertised listener at localhost:

shell
docker run --network=host -p 8080:8080 -e KAFKA_BROKERS=localhost:9092 docker.redpanda.com/redpandadata/console:latest

That option exists only on Linux, which is the one platform claim the README makes explicitly about network behaviour. Everywhere else, fix the advertised listener instead of the client.

The SASL_SSL path for a managed cloud broker

Against a remote cluster over SASL_SSL with trusted certificates, the same environment variable contract carries the credentials. For a Confluent Cloud deployment:

shell
docker run -p 8080:8080 -e KAFKA_BROKERS=pkc-4r000.europe-west1.gcp.confluent.cloud:9092 -e KAFKA_TLS_ENABLED=true -e KAFKA_SASL_ENABLED=true -e KAFKA_SASL_USERNAME=xxx -e KAFKA_SASL_PASSWORD=xxx docker.redpanda.com/redpandadata/console:latest

Two things follow from that line. Console takes SASL credentials as plain environment variables on the command line, so they are visible in the process table and in shell history on that host, and they are written into whatever container runtime log captures the command. The TLS flag is separate from the SASL flag.

If you have no cluster at all, the project keeps a compose file that brings up Redpanda and Console together at ./docs/local.

One credential set means no separation between reading and editing

Consumer group offset editing, group deletion, ACL and SASL-SCRAM user creation, connector config patching and task restarts are all listed features, alongside the broker credentials the README passes at startup. The feature list is honest about this: it advertises editing offsets by group, topic or partition, deleting a consumer group, and creating or editing ACLs, without describing a read-only role or an audit trail for who changed what. The README does not document an authorization or authentication layer inside Console beyond the broker credentials it is given.

If your Kafka ACLs are the only thing separating a support engineer from a production broker, plan access to the Console UI accordingly. Put Console behind your own authenticating proxy, or give it broker credentials scoped to read operations, if that separation matters to you.

Connectors, transforms and schema registry are three different admin surfaces

Beyond the data plane, Console reaches into control surfaces that a data viewer has no business touching. It manages connectors across multiple Kafka Connect clusters, patches their configs, reads current state and restarts tasks. It manages and monitors data transforms deployed inside a Redpanda cluster. It lists and edits Avro, Protobuf and JSON schemas in a schema registry.

These three are often conflated, and conflating them causes real incidents. Patching a connector config can change a consumer group name or an offset reset policy, which is a data-loss decision wearing an operations costume. Restarting a task is cheap when the connector is idempotent and expensive when it is not. Schema edits are the sharpest of the three, since a bad Avro or JSON schema write under a subject that producers already use will break consumers on the next record.

One build detail is worth knowing before you patch the frontend: the project runs react-doctor against React components for performance anti-patterns, and it also runs automatically in CI on every push and pull request; `bun run doctor` in frontend/ runs a local scan.

Where Kafbat Kafka UI takes the other approach

The closest comparable tool is Kafbat Kafka UI, a Java and Spring Boot application that fills the same slot: browse topics, read messages, inspect consumer groups, administer ACLs. The difference is in what each one assumes. Console is a TypeScript project with a distinct frontend/ and backend/ layout, and its maintainers ship prebuilt Docker images, single binaries for amd64 and arm64, and a Helm chart.

The consequence for an operator is about reach rather than features. Console is the natural pick when you want the Redpanda-side features, particularly Redpanda transforms, and when the container image means you never build the frontend yourself. Neither tool's documentation in this repository describes the other, so the choice comes down to which runtime your platform team already runs.

Editorial conclusion

Adopt Redpanda Console when your cluster is Kafka v1.0.0 or newer and your operators can be trusted with arbitrary JavaScript in a browser field. If you need role separation between viewers and editors, check the project documentation first, since the README does not describe it. Before anything else, verify that the advertised listener on your brokers is reachable from the container network, since the bootstrap address alone is not enough.

Frequently asked questions

What is Redpanda Console and what cluster does it connect to?

Redpanda Console is a web application for managing and debugging Kafka or Redpanda workloads. The README gives the prerequisite as any Kafka deployment compatible with v1.0.0 or later, plus a web browser to reach the UI.

How do I run Redpanda Console locally against Kafka on the same machine?

Because the Console container has its own network scope, the README uses host.docker.internal as the bootstrap server and requires the advertised listener to match, for example PLAINTEXT://host.docker.internal:9092. Linux users can instead run with --network=host and a localhost:9092 advertised listener.

Which message encodings does the Redpanda Console message viewer detect automatically?

JSON, Avro, Protobuf, CBOR, XML, MessagePack, text and binary hex view are supported, and detection is automatic for every one of them except Protobuf and CBOR.

Can Redpanda Console run without an existing Kafka or Redpanda cluster?

Yes. The repository keeps a docker-compose file under ./docs/local that launches Redpanda and Console together, and the README points to it for testing without an existing cluster.

How do I connect Redpanda Console to a remote SASL_SSL cluster such as Confluent Cloud?

Set KAFKA_BROKERS to the remote address and enable KAFKA_TLS_ENABLED and KAFKA_SASL_ENABLED, then pass KAFKA_SASL_USERNAME and KAFKA_SASL_PASSWORD as environment variables on the docker run command shown in the README.

Official sources

  1. Issues
  2. Project website
  3. README
  4. redpanda-data/console on GitHub
  5. Releases
Add this badge to your README

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/redpanda-data-console.svg)](https://hysenlabs.com/projects/redpanda-data-console)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/redpanda-data-console.svg)](https://hysenlabs.com/projects/redpanda-data-console)

Was this useful?