Self-Host Netdata: Real-Time Server Monitoring 2026

TL;DR

Netdata is a real-time server monitoring agent with ~73K GitHub stars. Install in 60 seconds, zero configuration required — it auto-discovers 800+ services and starts collecting per-second metrics immediately. Unlike Prometheus+Grafana, there's no separate database or dashboard to configure. It's the fastest way to get server visibility. Use Netdata for real-time monitoring (per-second resolution); use Prometheus+Grafana for long-term retention and custom queries.

Key Takeaways

• 73K GitHub stars, one of the most-starred monitoring tools
• Per-second resolution: Prometheus defaults to 15s scrape intervals; Netdata collects every second
• 800+ auto-discovered integrations: Nginx, Postgres, Redis, Docker, MySQL, Node.js apps — zero config
• ~1% CPU, ~70MB RAM agent overhead — minimal impact on monitored server
• Netdata Parent-Child: Aggregate metrics from multiple servers to one central Netdata instance
• Machine learning: Anomaly detection built-in — alerts when behavior deviates from baseline

---

Netdata vs Prometheus + Grafana

Feature	Netdata	Prometheus + Grafana
Setup time	~1 minute	~30 minutes
Configuration required	None	Moderate
Metric resolution	Per second (1s)	15s default
Auto-discovery	800+ integrations	Manual scrape config
Dashboards	Auto-generated	Manual (or imported)
Long-term retention	Limited (free cloud)	Configurable (local)
Custom PromQL queries	Via integration	Native
Memory usage	~70MB	~500MB+
ML anomaly detection	✅ Built-in	❌ (external)
Best for	Real-time operations	Long-term analysis

Use both: Many teams run Netdata for immediate visibility (spot problems within seconds) and Prometheus+Grafana for trend analysis and dashboards.

---

Install in 60 Seconds

Method 1: One-Line Install (Native)

# Installs Netdata agent directly on the OS:
bash <(curl -Ss https://my-netdata.io/kickstart.sh)

# Netdata starts immediately at:
# http://your-server-ip:19999

That's it. No config files. Netdata starts monitoring everything automatically.

Method 2: Docker

docker run -d --name=netdata \
  --pid=host \
  --network=host \
  --restart=unless-stopped \
  -v netdataconfig:/etc/netdata \
  -v netdatalib:/var/lib/netdata \
  -v netdatacache:/var/cache/netdata \
  -v /etc/passwd:/host/etc/passwd:ro \
  -v /etc/group:/host/etc/group:ro \
  -v /proc:/host/proc:ro \
  -v /sys:/host/sys:ro \
  -v /etc/os-release:/host/etc/os-release:ro \
  -e NETDATA_CLAIM_TOKEN=your-cloud-token \  # Optional: connect to Netdata Cloud
  --cap-add SYS_PTRACE \
  --security-opt apparmor=unconfined \
  netdata/netdata

Method 3: Docker Compose

# docker-compose.yml
version: '3.8'

services:
  netdata:
    image: netdata/netdata:latest
    container_name: netdata
    pid: host
    network_mode: host
    restart: unless-stopped
    cap_add:
      - SYS_PTRACE
      - SYS_ADMIN
    security_opt:
      - apparmor=unconfined
    volumes:
      - netdataconfig:/etc/netdata
      - netdatalib:/var/lib/netdata
      - netdatacache:/var/cache/netdata
      - /etc/passwd:/host/etc/passwd:ro
      - /etc/group:/host/etc/group:ro
      - /proc:/host/proc:ro
      - /sys:/host/sys:ro
      - /etc/os-release:/host/etc/os-release:ro
      - /var/run/docker.sock:/var/run/docker.sock:ro
    environment:
      - NETDATA_CLAIM_TOKEN=${NETDATA_CLAIM_TOKEN}  # Optional cloud token
      - NETDATA_CLAIM_URL=https://app.netdata.cloud
      - NETDATA_CLAIM_ROOMS=${NETDATA_CLAIM_ROOMS}

volumes:
  netdataconfig:
  netdatalib:
  netdatacache:

---

What Netdata Auto-Discovers

After installation, visit http://your-server:19999 — you'll see dashboards for everything running on the server:

System:

• CPU per core, idle, user, system, iowait, softirq
• Memory: used, cached, buffers, swap, NUMA
• Disk: read/write IOPS, utilization, backlog, latency
• Network: bandwidth per interface, packets, errors

Applications (auto-detected):

• Web servers: Nginx, Apache, Caddy (request rates, connections, response codes)
• Databases: PostgreSQL (queries/s, locks, vacuum), MySQL, MongoDB, Redis (ops/s, hit rate, keyspace)
• Containers: Docker stats per container (CPU, memory, network, I/O)
• Message queues: RabbitMQ, Kafka
• Languages: Node.js (eventloop lag), Python, Go runtime metrics
• Cloud: AWS, GCP, Azure metrics via API

Configuration for auto-discovery (usually not needed):

# /etc/netdata/go.d/nginx.conf (example — Netdata finds this automatically)
jobs:
  - name: local
    url: http://127.0.0.1/nginx_status

---

Multi-Server Setup: Parent-Child Mode

Monitor multiple servers from one central Netdata instance:

Child Servers (each monitored server)

# /etc/netdata/stream.conf on each child:
[stream]
    enabled = yes
    destination = parent-server-ip:19999
    api key = your-api-key-here

    # How often to stream (default: every second):
    buffer size bytes = 1048576
    reconnect delay seconds = 5

Parent Server (central aggregator)

# /etc/netdata/stream.conf on parent:
[your-api-key-here]
    enabled = yes
    allow from = *   # IP range of children
    default history = 3600
    default memory mode = ram
    health enabled by default = auto
    postpone alarms on connect seconds = 60

Now visit http://parent-server:19999 and see metrics from all connected servers in one UI.

---

Alerts and Notifications

Netdata comes with hundreds of pre-configured alerts (CPU > 90%, disk > 85%, memory > 80%, etc.).

Configure Slack Notifications

# /etc/netdata/health_alarm_notify.conf
SLACK_WEBHOOK_URL="https://hooks.slack.com/services/xxx/yyy/zzz"
DEFAULT_RECIPIENT_SLACK="#alerts"
SEND_SLACK="YES"

PagerDuty

SEND_PD="YES"
PD_SERVICE_KEY="your-pagerduty-service-key"

Email

SEND_EMAIL="YES"
DEFAULT_RECIPIENT_EMAIL="ops@yourdomain.com"
SENDMAIL="$(which sendmail)"

Custom Alert Rules

# /etc/netdata/health.d/my-alerts.conf
alarm: high_cpu_90s
  on: system.cpu
  lookup: average -90s percentage of user,system
  every: 30s
  warn: $this > 80
  crit: $this > 95
  info: CPU usage over the last 90 seconds
  to: sysadmin

---

Netdata Cloud (Optional, Free Tier)

Netdata Cloud provides a hosted dashboard that aggregates metrics from all your Netdata agents:

1. Sign up at app.netdata.cloud (free)
2. Get your claim token
3. Connect each agent: netdata-claim.sh -token=YOUR_TOKEN -rooms=YOUR_ROOM_ID

Free tier: Unlimited nodes, 3-day metric retention Pro tier: Longer retention, team features

For full data privacy, skip Netdata Cloud and use the local dashboard or the Parent-Child streaming setup above.

---

Prometheus + Grafana Integration

If you already run Prometheus, Netdata exposes a Prometheus endpoint:

# Access Netdata's Prometheus metrics:
curl http://your-server:19999/api/v1/allmetrics?format=prometheus

# In prometheus.yml:
scrape_configs:
  - job_name: netdata
    metrics_path: /api/v1/allmetrics
    params:
      format: [prometheus]
    static_configs:
      - targets: ['your-server:19999']

This combines Netdata's 1-second collection with Prometheus's long-term storage and Grafana's query capabilities.

---

Resource Usage

Configuration	CPU	RAM
Agent only (no cloud)	~1%	~70MB
Agent + Parent streaming	~2%	~150MB
Parent aggregating 10 nodes	~5%	~500MB

Netdata is specifically designed to be low-overhead. The 1% CPU figure is on a typical server with 100+ metrics collected per second.

---

Securing the Dashboard

By default, Netdata listens on port 19999 (all interfaces). Restrict access:

# /etc/netdata/netdata.conf
[web]
    bind to = 127.0.0.1   # Local only
    # Or bind to specific IP: bind to = 192.168.1.10

Then access via SSH tunnel:

ssh -L 19999:localhost:19999 user@your-server
# Open http://localhost:19999 locally

Or put behind Nginx with basic auth:

location / {
    proxy_pass http://127.0.0.1:19999;
    auth_basic "Monitoring";
    auth_basic_user_file /etc/nginx/.htpasswd;
}

---

Quick Update

# Update native install:
bash <(curl -Ss https://my-netdata.io/kickstart.sh) --reinstall

# Docker:
docker pull netdata/netdata
docker compose up -d

---

Compare all open source monitoring tools at OSSAlt.com/alternatives/datadog.