A modern, enterprise-grade web console for managing NATS JetStream clusters. Built with Next.js, Node.js, and TypeScript, featuring real-time monitoring and a developer-friendly experience.

Open Source | Maintained by KLogic

Free and Open Source Software (FOSS) - Use, modify, and distribute freely under the Apache License 2.0. Contributions welcome!

• Multi-cluster Support - Connect and manage multiple NATS JetStream clusters from a single dashboard
• Connection Testing - Verify cluster connectivity before saving
• Health Monitoring - Real-time cluster health status with server info
• Secure Connections - Support for TLS, credentials, and token authentication

• Stream CRUD - Create, update, delete, and configure streams
• Message Browser - Browse messages with pagination, JSON formatting, expand/collapse
• Message Publishing - Publish messages directly from the UI
• Message Export - Export messages to JSON or CSV format
• Message Replay - Replay messages to different subjects
• Stream Purge - Purge stream messages with confirmation
• Metrics Charts - Message throughput and data throughput visualization

• Consumer CRUD - Create, update, and delete consumers
• Lag Visualization - Real-time lag monitoring with progress bars
• Pause/Resume - Pause and resume consumers
• Metrics Charts - Consumer lag, pending, and ack rate visualization
• Delivery Policies - Configure various delivery policies

• WebSocket Updates - Live metrics streaming via WebSocket
• Interactive Charts - ECharts-based visualization
• Historical Trends - ClickHouse-backed time-series analytics
• Gauge Charts - Memory, connections, and storage usage

• Alert Rules - Create rules for lag, throughput, storage, and connection health
• Notification Channels - Email, Slack, Webhook, PagerDuty, Microsoft Teams, Google Chat
• Incident Management - Create, acknowledge, resolve, and close incidents
• Alert History - View historical alerts and events

• Dashboard Builder - Drag-and-drop widget placement
• Widget Library - Line charts, bar charts, gauges, stat cards, tables, pie charts
• Dashboard Sharing - Share dashboards with team members

• Organizations - Multi-tenant organization management
• Teams - Team-based access control within organizations
• Role-Based Access Control (RBAC) - Fine-grained permissions
• Two-Factor Authentication (2FA) - TOTP-based authentication
• API Key Management - Generate and manage API keys with expiration
• IP Allowlisting - Restrict access by IP address or CIDR range
• Audit Logging - Track all user actions with ClickHouse storage

• Data Retention Policies - Configure retention for metrics, audit logs, and events
• Audit Trail Export - Export audit logs to JSON or CSV
• Compliance Reports - Security metrics and recommendations
• GDPR Compliance - Data export (Article 20) and account deletion (Article 17)

• Modern UI - Clean, responsive design with shadcn/ui components
• Dark Mode - System, light, and dark theme support
• REST API - Full-featured REST API for integrations
• WebSocket API - Real-time event streaming

Connect and manage multiple NATS JetStream clusters from a single dashboard.

View detailed cluster information including server stats, health status, and real-time metrics.

Monitor stream health with message counts, storage usage, and throughput metrics.

Browse and inspect messages with JSON formatting, expand/collapse functionality, and message metadata.

Automatic schema detection and visualization for structured message payloads.

Configure stream settings including retention policies, storage limits, and replication.

Track consumer performance with lag monitoring, pending messages, and delivery metrics.

Configure consumer settings including delivery policies, ack policies, and replay options.

Real-time analytics with interactive charts for throughput, latency, and resource utilization.

Create and manage alert rules with golden templates for common monitoring scenarios.

Build custom dashboards with drag-and-drop widgets for personalized monitoring views.

Choose the deployment method that fits your needs:

Pre-built container images are available on GitHub Container Registry (GHCR):

# Pull latest all-in-one image
docker pull ghcr.io/klogichq/nats-console:latest

# Pull specific version
docker pull ghcr.io/klogichq/nats-console:1.0.0

# Pull individual services
docker pull ghcr.io/klogichq/nats-console-api:latest
docker pull ghcr.io/klogichq/nats-console-web:latest
docker pull ghcr.io/klogichq/nats-console-workers:latest

The simplest way to try NATS Console. A single container with all services embedded.

# Run the container from GHCR
docker run -d \
  --name nats-console \
  -p 3000:3000 \
  -p 3001:3001 \
  -p 4222:4222 \
  -p 8222:8222 \
  -e JWT_SECRET="your-secret-key-change-in-production" \
  ghcr.io/klogichq/nats-console:latest

# Build the image locally
docker build -t nats-console:allinone .

# Run the container
docker run -d \
  --name nats-console \
  -p 3000:3000 \
  -p 3001:3001 \
  -p 4222:4222 \
  -p 8222:8222 \
  -e JWT_SECRET="your-secret-key-change-in-production" \
  nats-console:allinone

docker run -d \
  --name nats-console \
  -p 3000:3000 \
  -p 3001:3001 \
  -p 4222:4222 \
  -v nats-console-postgres:/var/lib/postgresql/data \
  -v nats-console-redis:/var/lib/redis \
  -v nats-console-clickhouse:/var/lib/clickhouse \
  -v nats-console-nats:/var/lib/nats \
  -e JWT_SECRET="your-secret-key-change-in-production" \
  ghcr.io/klogichq/nats-console:latest

Same all-in-one container but managed with Docker Compose for easier configuration.

# Start
docker-compose -f docker-compose.allinone.yml up -d

# View logs
docker-compose -f docker-compose.allinone.yml logs -f

# Stop
docker-compose -f docker-compose.allinone.yml down

# Stop and remove data
docker-compose -f docker-compose.allinone.yml down -v

Create a .env file:

cp .env.example .env
# Edit .env with your settings

JWT_SECRET=your-secure-random-string-here
JWT_EXPIRES_IN=15m
JWT_REFRESH_EXPIRES_IN=7d

For production deployments with separate, scalable services.

• Docker & Docker Compose
• At least 4GB RAM recommended

1. Create environment file

cp .env.example .env.prod

2. Edit production environment (.env.prod)

NODE_ENV=production

# Database
DATABASE_URL=postgresql://nats_console:secure_password@postgres:5432/nats_console
POSTGRES_PASSWORD=secure_password

# Redis
REDIS_URL=redis://redis:6379

# ClickHouse
CLICKHOUSE_URL=http://clickhouse:8123
CLICKHOUSE_DATABASE=nats_console

# NATS
NATS_URL=nats://nats:4222

# Security (IMPORTANT: Use a secure random string!)
JWT_SECRET=generate-with-openssl-rand-hex-32
JWT_EXPIRES_IN=15m
JWT_REFRESH_EXPIRES_IN=7d

3. Start services

# Build and start
docker-compose -f docker-compose.prod.yml --env-file .env.prod up -d

# Run database migrations
docker-compose -f docker-compose.prod.yml exec api npx prisma migrate deploy

# Check status
docker-compose -f docker-compose.prod.yml ps

# View logs
docker-compose -f docker-compose.prod.yml logs -f

# Include nginx profile
docker-compose -f docker-compose.prod.yml --profile with-nginx up -d

# Scale API instances
docker-compose -f docker-compose.prod.yml up -d --scale api=3

# Scale workers
docker-compose -f docker-compose.prod.yml up -d --scale workers=2

For active development with hot reload. Infrastructure runs in Docker, apps run locally.

• Node.js 20+
• pnpm 9+
• Docker & Docker Compose

1. Clone and install

git clone https://github.com/your-org/nats-console.git
cd nats-console
pnpm install

2. Start infrastructure services

# Start PostgreSQL, Redis, ClickHouse, NATS
docker-compose -f docker-compose.dev.yml up -d

# Or use the existing docker-compose.yml
docker-compose up -d

3. Setup environment

# Copy environment files
cp apps/api/.env.example apps/api/.env
cp apps/web/.env.example apps/web/.env
cp apps/workers/.env.example apps/workers/.env

4. Initialize database

# Generate Prisma client
make prisma-generate

# Run migrations
make prisma-migrate

5. Start development servers

# Start all services with hot reload
make dev

# Or start individually
make api-dev    # API only
make web-dev    # Web only
make workers-dev # Workers only

make setup && make dev

make dev              # Start all services in dev mode
make api-dev          # Start API only
make web-dev          # Start Web only
make workers-dev      # Start Workers only

make db-up            # Start database containers
make db-down          # Stop database containers
make db-shell-postgres  # PostgreSQL shell
make db-shell-redis     # Redis CLI
make db-shell-clickhouse # ClickHouse client
make db-shell-nats      # NATS CLI

make prisma-generate  # Generate Prisma client
make prisma-migrate   # Run migrations
make prisma-studio    # Open Prisma Studio
make prisma-reset     # Reset database

make build            # Build all packages
make start            # Start in production mode
make health           # Check health of all services

make docker-build-allinone  # Build all-in-one image
make docker-up-allinone     # Start all-in-one container
make docker-down            # Stop all containers

┌─────────────────────────────────────────────────────────────────┐
│                          Browser                                │
└─────────────────────────────┬───────────────────────────────────┘
                              │
                        ┌─────▼─────┐
                        │  Web UI   │
                        │ (Next.js) │
                        └─────┬─────┘
                              │ HTTP/REST
                              │
                        ┌─────▼─────┐
                        │    API    │◄─────────────────────────────┐
                        │ (Fastify) │                              │
                        └─────┬─────┘                              │
                              │                                    │
          ┌───────────────────┼───────────────────┐                │
          │                   │                   │                │
    ┌─────▼─────┐       ┌─────▼─────┐       ┌─────▼─────┐    ┌─────▼──────┐
    │ PostgreSQL│       │   Redis   │       │ ClickHouse│    │  Workers   │
    │   (Data)  │       │  (Cache)  │       │ (Metrics) │    │(Background)│
    └───────────┘       └───────────┘       └───────────┘    └─────┬──────┘
                                                                   │
          ┌────────────────────────────────────────────────────────┘
          │
          │  ┌─────────────────────────────────────────────────────┐
          │  │          NATS JetStream Clusters                    │
          │  │  (Managed by API - streams, consumers, messages)    │
          └──►                                                     │
             └─────────────────────────────────────────────────────┘

Data Flow:

• Web UI → API: All frontend requests go through the REST API
• API → NATS: API connects to NATS clusters to manage streams/consumers
• Workers → NATS: Background jobs for metrics collection and alerting

The examples/ directory contains sample NATS applications:

cd examples

# Install dependencies
pnpm install

# Setup example streams
pnpm run setup-streams

# Run message producer
pnpm run producer

# Run message consumer
pnpm run consumer

# Run high-volume load test
pnpm run load-test

See .env.example for the complete list.

# Check logs
docker logs nats-console

# Check if ports are in use
lsof -i :3000,:3001,:4222

# Restart with fresh data
docker-compose down -v
docker-compose up -d

# Check PostgreSQL is running
docker exec nats-console-postgres pg_isready

# Check Redis
docker exec nats-console-redis redis-cli ping

# Check ClickHouse
curl http://localhost:8123/ping

# Stop all containers and remove volumes
docker-compose down -v

# Remove images
docker rmi nats-console:allinone

# Start fresh
docker-compose up -d --build

We welcome contributions from the community! This project is open source and thrives on community involvement.

1. Fork the repository
2. Create a feature branch: git checkout -b feature/my-feature
3. Commit changes: git commit -am 'Add feature'
4. Push to branch: git push origin feature/my-feature
5. Open a Pull Request

• Bug Reports - Found a bug? Open an issue with details
• Feature Requests - Have an idea? We'd love to hear it
• Documentation - Help improve docs and examples
• Code - Submit PRs for bug fixes or new features
• Testing - Help test and report issues

See Local Development Mode for setting up your development environment.

Apache License 2.0 - see LICENSE for details.

This is free and open source software. You are free to use, modify, and distribute it under the terms of the Apache License 2.0.