PeaNUT

A practical look at the open-source NUT dashboard for anyone who’s tired of staring at a command line to check if their UPS battery is dying.

TL;DR

• What it is: A web dashboard for Network UPS Tools (NUT) — the open-source daemon that communicates with UPS hardware. PeaNUT adds a clean visual layer on top of NUT’s otherwise terminal-only interface [README].
• Who it’s for: Homelabbers, small business owners, and self-hosting enthusiasts who have a UPS device (APC, Eaton, CyberPower, etc.) and want real-time battery status, load percentage, and runtime estimates without SSHing into their server [README].
• Cost: $0 for the software (Apache-2.0 license). Runs on your existing hardware or a Raspberry Pi 4 [README].
• Key strength: Covers the full NUT monitoring stack in one container — live stats, InfluxDB/Grafana integration, Prometheus scraping, and a Homepage widget — without requiring you to write a line of code [README].
• Key weakness: This tool only matters if you already run NUT. If you don’t have NUT configured and pointed at your UPS hardware, PeaNUT has nothing to display. Setup complexity lives upstream, not in PeaNUT itself.

---

What is PeaNUT

If you own a UPS (Uninterruptible Power Supply) and self-host anything, you’ve probably already discovered NUT — Network UPS Tools. NUT is the standard open-source package for talking to UPS hardware over USB or serial, and it runs quietly in the background reporting battery level, input voltage, output load, and estimated runtime to the rest of your homelab. The problem is that NUT’s native interfaces are a collection of command-line tools. upsc, upscmd, upsmon — functional, but not the kind of thing you want to babysit in a terminal at 2am when your power flickers [README].

PeaNUT fills that gap. It’s a web dashboard built in Next.js that connects to a NUT server and renders everything NUT reports into a readable, auto-refreshing UI. You get a status table showing all your connected UPS devices, live charts for load percentage and battery charge, and the ability to issue commands to the UPS without touching a terminal [README].

The project is maintained by a single developer (Brandawg93) on GitHub under the Apache-2.0 license, with 1,358 stars and 38 forks as of the data provided. It’s a focused, single-purpose tool — and that focus is its biggest selling point.

---

Why People Choose It

No independent third-party reviews of PeaNUT were available in the research data for this article. What follows draws from the project’s GitHub README and repository documentation.

The honest reason people run PeaNUT is simple: NUT has no good built-in UI, and writing Grafana dashboards from scratch is tedious. The existing options before PeaNUT were either bare-bones NUT web interfaces bundled with some Linux distributions (functional but circa-2005 in appearance), or a full Grafana + InfluxDB stack built by hand. PeaNUT collapses that second option into a single Docker container.

A secondary reason is Homepage integration. Homepage is the most popular self-hosted startpage right now, and PeaNUT ships native widget support for it — meaning you can embed a live UPS status block on your homelab dashboard without any custom configuration [README]. For the r/selfhosted crowd, this is a notable quality-of-life feature.

The Apache-2.0 license is worth noting too: it’s more permissive than GPL, meaning commercial use, redistribution, and embedding in other products are all allowed without restriction.

---

Features

Based on the README:

Core monitoring:

• Real-time status and statistics for all UPS devices connected to NUT [README]
• Customizable dashboard layout with support for multiple UPS devices simultaneously [README]
• Live charts showing battery charge, load percentage, voltage, and runtime [README]
• Terminal access to the NUT server directly from the browser — no SSH required [README]
• Execute NUT commands on UPS devices from the UI [README]

Configuration:

• Settings configured via the web UI (no config file required) [README]
• Manual override via /config/settings.yml for declarative setups [README]
• Basic auth via environment variables (WEB_USERNAME / WEB_PASSWORD) [README]
• SSL termination supported via cert/key paths, or handled by a reverse proxy [README]
• BASE_PATH variable for deployments behind a reverse proxy [README]

Integrations:

• InfluxDB v2 — writes UPS metrics for historical monitoring via Grafana [README]
• Prometheus — exports metrics for alerting pipelines [README]
• Homepage widgets — native support for the gethomepage.dev dashboard [README]
• REST API for pulling UPS data into other tools [README]

Platform support:

• linux/amd64 (standard x86 servers) [README]
• linux/arm64 (Raspberry Pi 4 and newer) [README]
• Raspberry Pi 3 and older (arm/v7) dropped as of v5.17.0 [README]

---

Pricing: Self-Hosted Math

PeaNUT has no cloud or SaaS version. It is purely self-hosted software under the Apache-2.0 license. The cost structure is:

PeaNUT itself: $0.

Infrastructure you need:

• A machine running NUT pointed at your UPS hardware — this is the prerequisite. PeaNUT is a frontend; NUT is the backend.
• A container host: Raspberry Pi 4 (you likely already own one), an existing homelab server, or a $4–6/month VPS. Note that a VPS approach only makes sense if your NUT server is network-reachable from outside your LAN, which is an unusual configuration. Most people run PeaNUT on-premises alongside NUT.

Commercial alternatives for context:

• APC’s Network Management Card 2 (AP9630): retail ~$200–300, locks you into APC hardware only
• Eaton’s Intelligent Power Manager (IPM): commercial software, pricing not publicly listed, targets enterprise deployments
• CyberPower PowerPanel Business: free for basic, paid tiers for enterprise features

If you already run NUT, PeaNUT costs you nothing beyond the container slot. If you’re choosing between buying a $200 network management card from your UPS vendor and running PeaNUT free on a Pi 4 you already own, the math is straightforward.

---

Deployment Reality Check

PeaNUT’s Docker installation is three lines [README]:

services:
  peanut:
    image: brandawg93/peanut:latest
    container_name: PeaNUT
    restart: unless-stopped
    volumes:
      - /path/to/config:/config
    ports:
      - 8080:8080
    environment:
      - WEB_PORT=8080

That part is easy. The non-trivial part is everything upstream of PeaNUT.

NUT needs to be installed, configured with a ups.conf pointing at your specific UPS hardware, and exposing its network port. On a Raspberry Pi connected via USB to a UPS, this means installing nut, editing /etc/nut/ups.conf with your hardware’s driver, setting MODE=netserver in /etc/nut/nut.conf, and confirming upsc returns real data before you even open PeaNUT’s browser tab. That’s the setup that trips up non-technical users — not PeaNUT, but NUT.

What can go wrong:

• NUT configuration is hardware-specific. Different UPS brands need different drivers (usbhid-ups, apcsmart, blazer_usb, etc.). If you pick the wrong driver, NUT silently fails to connect and PeaNUT shows nothing.
• USB permissions on Linux. NUT needs read access to the USB device. On some distros this means adding the nut user to the dialout or plugdev group.
• Raspberry Pi 3 support dropped. As of v5.17.0 PeaNUT no longer publishes arm/v7 images [README]. If you’re running a Pi 3, you’re stuck on an older release or building from source.
• Reverse proxy config requires extra rules. The README flags that missing sub_filter rules in nginx configs cause favicon and font loading errors — an annoyance that requires reading the wiki to resolve [README].

Realistic time estimates:

• If NUT is already running and you just need the dashboard: 10 minutes.
• If you’re starting from scratch (install NUT, configure hardware, get upsc working, deploy PeaNUT): 1–3 hours, depending on your UPS hardware and familiarity with Linux.
• If you’re not comfortable with Linux package management: budget an afternoon plus time reading NUT documentation before you even touch PeaNUT.

The InfluxDB integration adds another layer: you’ll need an InfluxDB v2 instance running, a bucket configured, and an API token. Worth it if you want 90-day battery history charts in Grafana; optional if you just want a live status page.

---

Pros and Cons

Pros

• Apache-2.0 license. Completely permissive — commercial use, modification, redistribution, all fine [README].
• Covers the full stack. Live dashboard + InfluxDB for history + Prometheus for alerting + Homepage widget — four common monitoring needs in one container [README].
• Terminal access in the browser. Sending test.battery.start to a UPS without SSH is a genuine quality-of-life improvement for anyone managing hardware remotely [README].
• Supports multiple UPS devices. Useful for anyone running multiple devices on one NUT server [README].
• Configurable without editing files. UI-based settings with YAML fallback for declarative infrastructure fans [README].
• Basic auth built in. WEB_USERNAME and WEB_PASSWORD environment variables lock down both the web UI and the API with a single change [README].
• Actively maintained. 1,294 commits as of last check; Docker Hub image is current.

Cons

• Niche prerequisite. Only useful if you run NUT. NUT only matters if you own UPS hardware. If you’re evaluating this tool, the “who shouldn’t use it” section below applies to a lot of people.
• Raspberry Pi 3 support dropped. If you have older ARM hardware, you’re out [README].
• NUT complexity lives upstream. PeaNUT can’t help you if NUT isn’t talking to your UPS. Most deployment pain is in NUT, not PeaNUT — but users often can’t distinguish between them.
• Single maintainer. This is a one-developer project. Longevity depends on that developer’s continued interest. No company or foundation behind it.
• No alerting built in. PeaNUT shows you status but doesn’t send emails or Slack messages when battery drops below 20%. That’s Prometheus + Alertmanager’s job — PeaNUT only exports the metrics.
• No user roles or multi-user auth. One username, one password. Fine for a personal homelab, inadequate for any shared environment.
• REST API documentation is partial. The README table of API endpoints is truncated in the available data; the full API surface is in the wiki [README].

---

Who Should Use This / Who Shouldn’t

Use PeaNUT if:

• You own UPS hardware and run NUT, or are planning to set up NUT.
• You want to replace watch upsc myups with something you can actually look at on a phone.
• You run Homepage and want a native UPS widget without building a custom integration.
• You’re setting up Grafana for homelab monitoring and need a pre-built Prometheus exporter for UPS data [README].
• You run a Pi 4 or x86 machine — both architectures are fully supported [README].

Skip it if:

• You don’t own a UPS. This tool has exactly zero value without UPS hardware.
• You own a UPS but it’s connected to a Windows machine and you’ve never set up NUT. The NUT-on-Windows path exists but adds friction.
• You’re running a Raspberry Pi 3 or older ARM hardware — the arm/v7 image was dropped in v5.17.0 [README].
• You need alerting. PeaNUT shows status; it doesn’t page you. Wire Prometheus + Alertmanager separately.
• You need multi-user access with different permission levels. There’s no RBAC here.

---

Alternatives Worth Considering

• NUT’s built-in web interface (nut-cgi) — ships with NUT, requires Apache or nginx configuration, functional but primitive. Free, no Docker required. Worth knowing it exists if you just need a basic status page.
• Grafana + InfluxDB with manual dashboards — more work to set up, but more flexible. PeaNUT’s InfluxDB integration actually feeds into this stack, so they’re not mutually exclusive.
• Home Assistant NUT integration — if you already run Home Assistant, it has a native NUT sensor that gives you all the same data inside your home automation platform. No separate container needed.
• apcupsd + apcupsd-cgi — if you exclusively use APC hardware and don’t want to bother with NUT, apcupsd is the APC-specific daemon with its own web interface. Narrower support, simpler for APC-only setups.
• Uptime Kuma — general monitoring platform, not UPS-specific. It can ping your NUT host to confirm it’s alive but can’t read battery status or load.
• PowerPanel Business (CyberPower) — if your UPS is CyberPower hardware, this is the vendor’s own management software. Free for basic use, proprietary, works on Windows and Linux.

For most NUT users who want a dashboard without building one from scratch, PeaNUT is the clearest path. The alternatives are either vendor-locked, require more manual assembly, or solve a different problem entirely.

---

Bottom Line

PeaNUT is a well-scoped tool doing exactly one thing: putting a clean web interface on top of NUT. It doesn’t try to replace NUT, doesn’t try to be a full monitoring platform, and doesn’t require you to write a line of configuration if you deploy it via Docker. For anyone already running NUT in their homelab, the value is immediate — replace the terminal habit of running upsc with a browser tab that auto-refreshes, and optionally feed that data into Grafana for history. The InfluxDB and Prometheus support are the features that lift it above a simple status page into something that belongs in a real observability stack. The practical ceiling is the lack of alerting and single-developer maintenance trajectory. If you own UPS hardware and run NUT, there’s no reason not to run it.

If the NUT setup itself is the blocker — and for non-technical users it often is — that’s a different problem. NUT requires Linux familiarity and hardware-specific configuration that PeaNUT can’t abstract away.

---

Sources

All technical claims in this article are sourced from the PeaNUT project repository. No independent third-party reviews of PeaNUT were available in the research data for this article.

1. PeaNUT README — Feature list, environment variables, installation instructions, platform support, authentication, and API documentation. https://github.com/Brandawg93/PeaNUT
2. PeaNUT GitHub Repository — Stars, forks, license, commit history, Docker image metadata. https://github.com/Brandawg93/PeaNUT
3. PeaNUT Docker Hub — Pull count, image availability, platform tags. https://hub.docker.com/r/brandawg93/peanut
4. Network UPS Tools (NUT) Project — Background on the underlying daemon that PeaNUT fronts. https://networkupstools.org
5. PeaNUT Wiki — Reverse Proxy Setup — Referenced for nginx sub_filter issue and configuration notes. https://github.com/Brandawg93/PeaNUT/wiki/Reverse-Proxy-Setup-for-PeaNUT