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.
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.
Star history
- redpanda-data/console4,353 ★ · +19
| Repository | 2026-09-23 | 2026-11-15 |
|---|---|---|
| redpanda-data/console | 4.3k | 4.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:
docker run -p 8080:8080 -e KAFKA_BROKERS=host.docker.internal:9092 docker.redpanda.com/redpandadata/console:latestPort 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:
docker run --network=host -p 8080:8080 -e KAFKA_BROKERS=localhost:9092 docker.redpanda.com/redpandadata/console:latestThat 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:
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:latestTwo 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
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.
[](https://hysenlabs.com/projects/redpanda-data-console)Star history chart for your README
[](https://hysenlabs.com/projects/redpanda-data-console)Was this useful?