Chia Monitoring with Grafana and Prometheus: See Your Farm in Real Time

Key Takeaways

• Chia monitoring with Grafana uses a three-part stack: chia-exporter (data bridge), Prometheus (database), and Grafana (visual dashboard).
• The official chia-exporter from Chia Network connects to your node’s RPC services via WebSocket and exposes metrics at port 9914/metrics.¹
• Harvester lookup times above 5 seconds put you at risk of missing block rewards — Grafana makes this visible at a glance.²
• Pre-built Grafana dashboard IDs (17939, 16456, 20070) let you skip hours of setup and start monitoring in minutes.³
• Docker makes running the full Prometheus + Grafana + chia-exporter stack much easier than bare metal — especially for beginners.⁴
• Chia Network uses this exact same chia-exporter stack to power their own public dashboards.⁵

If you are farming Chia, you need to know what is happening inside your farm right now — not after something goes wrong. Chia monitoring with Grafana gives you a live window into your farm’s health, your plot counts, your XCH balance, and the one metric that could be quietly costing you rewards: harvester lookup time. This guide walks you through the full setup, explains why each piece matters, and shows you how to get a working dashboard without starting from scratch.

Why Your Chia Farm Needs Real-Time Monitoring

Most Chia farmers start by checking the GUI every day or glancing at log files. That works fine when your farm is small. But as your plot count grows — or when you add remote harvesters — the logs become a wall of text that is hard to read and easy to miss. Problems can hide in plain sight for hours, even days, before you notice them.

The bigger problem is silent failures. A slow hard drive, a harvester that lost its network connection, or a node that fell out of sync might not throw an obvious error. But every minute it goes undetected is a minute your farm is not competing for block rewards. That is money left on the table.

Real-time monitoring with Grafana solves this. Instead of hunting through logs, you get color-coded charts that update automatically. Anything that spikes or drops out of range becomes impossible to miss.

The 5-Second Rule — A Critical Metric Farmers Often Miss

Here is something that catches many farmers off guard. Every 9.375 seconds, the Chia network broadcasts a signage point — a challenge your harvesters must respond to by searching their plots for proof.⁶ Your harvester has a hard limit to respond. According to official Chia documentation, keeping your maximum lookup time at around five seconds is a good idea in order to avoid missing signage points.² If a lookup takes longer than 30 seconds, that proof is considered invalid — you cannot win that block, no matter how many plots you have.

The dangerous part? Slow lookups do not always throw a visible warning in the GUI. Farmers have reported farming for days without a single win, only to discover their harvesters were regularly timing out.⁷ A Grafana dashboard shows your lookup time history as a graph. A single glance tells you whether you have a problem. Without it, you might farm for weeks at reduced efficiency without ever knowing.

How the Chia Monitoring Grafana Stack Works

The Chia monitoring Grafana system is made up of three tools that pass information from one to the next. Think of it like a relay race. Your Chia node holds all the data. chia-exporter reads it and passes it to Prometheus. Prometheus stores it over time. Grafana reads from Prometheus and draws it as charts on your screen. Each piece does one job, and they all work together seamlessly.

Understanding this flow before you set anything up makes troubleshooting much easier if something goes wrong.

chia-exporter — The Data Bridge

The official chia-exporter, maintained by Chia Network on GitHub, is a Go application that runs alongside your Chia installation.¹ It connects to your Chia node’s RPC (Remote Procedure Call) services via WebSocket. When your node reports a new event — like a new block, a harvester response, or a wallet balance change — chia-exporter catches that data and translates it into a format Prometheus can read. It then serves those metrics at a simple HTTP endpoint: //your-node-ip:9914/metrics.

One important detail: chia-exporter is designed to run on the same machine as your Chia blockchain installation. It reads your Chia config from ~/.chia/mainnet/ by default.¹ Chia Network uses this exact same tool to power their own public network dashboards.⁵ That is a strong signal it is production-ready.

Prometheus — The Time-Series Database

Prometheus is a free, open-source monitoring system originally built at SoundCloud and now part of the Cloud Native Computing Foundation — the same organization that hosts Kubernetes.⁸ Prometheus collects and stores metrics as time-series data, meaning every measurement is stamped with the exact time it was recorded.⁹ This is what lets Grafana show you how your harvester performance changed over the last hour, day, or week.

Prometheus works on a “pull” model. You give it a list of targets (like your chia-exporter endpoint), and it visits those targets at a set interval — usually every 15 seconds — and scrapes the current values. All of that data is saved locally so Grafana can query it later. Prometheus is designed for reliability: it runs independently and does not need a network connection to external services to stay functional.¹⁰

Grafana — The Visual Dashboard

Grafana is the front end of the entire system. It connects to Prometheus as a data source and uses its powerful query language (PromQL) to pull specific metrics and draw them as charts, gauges, tables, and stat panels. For Chia farmers, Grafana turns raw numbers like chia_harvester_search_time into a readable graph that immediately shows whether your lookups are getting slower. The best part is that you do not need to build your dashboard from scratch — the Chia community has already done that for you (more on that below).

Quick Decision Table: Which Chia Monitoring Setup Is Right for You?

How to Set Up Chia Monitoring with Grafana — Step by Step

This section covers the three core steps for getting chia monitoring with Grafana running on a Linux machine (Ubuntu). If you are on Windows or Mac, the concepts are the same, but the Docker path (covered further below) is much easier.

Step 1 — Install chia-exporter on Your Node

Chia Network provides chia-exporter as a Debian package through their official repository. On Ubuntu, run the following commands to add the repository and install it:

# Add Chia's GPG key and repository
curl -sL //repo.chia.net/FD39E6D3.pubkey.asc | sudo gpg --dearmor -o /usr/share/keyrings/chia.gpg
echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/chia.gpg] //repo.chia.net/chia-exporter/debian/ stable main" \
  | sudo tee /etc/apt/sources.list.d/chia-exporter.list > /dev/null

# Install
sudo apt-get update
sudo apt-get install chia-exporter

# Start the service (replace YOUR-USERNAME with your actual username)
sudo systemctl start chia-exporter@YOUR-USERNAME.service
sudo systemctl enable chia-exporter@YOUR-USERNAME.service

After starting the service, confirm it is running with sudo systemctl status chia-exporter@YOUR-USERNAME.service. Metrics will be available at //localhost:9914/metrics. You should see a page of Prometheus-formatted metrics like chia_blockchain_height, chia_harvester_plots_total, and more.¹

Step 2 — Configure Prometheus to Scrape Your Chia Metrics

Install Prometheus and create or edit your prometheus.yml configuration file. Below is the core scrape config you need for a single Chia node. If you have multiple harvesters, add an entry for each one’s IP address and port.

global:
  scrape_interval: 15s

scrape_configs:
  - job_name: "prometheus"
    static_configs:
      - targets: ["localhost:9090"]

  - job_name: "node"
    static_configs:
      - targets: ["localhost:9100"]   # node-exporter for CPU/disk stats

  - job_name: "chia-exporter"
    static_configs:
      - targets: ["localhost:9914"]
    labels:
      application: 'chia-blockchain'
      network: 'mainnet'

For a multi-harvester setup where chia-exporter exposes separate endpoints per role, you can define separate scrape jobs with different metrics_path values — for example /farmer/metrics and /harvester-1/metrics.¹¹ This is how the more advanced dashboards display per-harvester breakdown charts. Once Prometheus is running, visit //localhost:9090 to verify it is successfully scraping your targets.

Step 3 — Connect Grafana and Import a Ready-Made Dashboard

Install Grafana and open it in your browser at //localhost:3000. The default login is admin / admin — change this immediately. Then add Prometheus as a data source by going to Configuration → Data Sources → Add data source → Prometheus. Set the URL to //localhost:9090 and click Save & Test. If it says “Data source is working,” you are ready to import a dashboard.

Go to Dashboards → Import, enter a dashboard ID from the table below, and select your Prometheus data source. Grafana will pull the dashboard layout automatically. You may need to match the label variables (like job, instance, or node_id) to what your Prometheus config is using. The dashboard should populate with live data within one scrape interval (about 15 seconds).³

The Best Pre-Built Grafana Dashboards for Chia Farming

You do not need to build your Grafana dashboard from scratch. Several excellent community and official dashboards are ready to import. Below is a summary of the most widely used options.

For most farmers, dashboard ID 16456 (Chia Farm Dashboard) is the strongest all-around choice. It supports multiple harvesters, displays all core farm health metrics, and is built on the official chia-exporter — the same one Chia Network themselves use.⁵ If you are running a large operation with five or more harvesters, ID 20070 is purpose-built to scrape each harvester independently rather than relying on the central farmer to relay metrics.

Docker vs. Bare Metal for Chia Grafana Monitoring

When it comes to actually running your monitoring stack, you have two main paths: install everything natively on your system (bare metal) or run everything inside Docker containers. Both work, but they suit different types of users.

The chiamon project on GitHub by Kevin Retzke combines chia-exporter, Prometheus, Loki (for log collection), and Grafana into a single docker-compose file.¹² This is the fastest way for a beginner to get a full monitoring stack running. Note that chia-exporter needs access to your Chia SSL certificates (stored in ~/.chia/mainnet/config/ssl/) to communicate with the RPC API — the Docker setup uses host networking mode to simplify this.

“chia-exporter establishes a WebSocket connection to the Chia RPC services, listens for metrics events, and then translates the data it receives into a Prometheus HTTP endpoint.”— Chris Marslender, Software Engineer, Chia Network, Announcing Chia Dashboards, April 6, 2022⁵

Key Metrics to Track on Your Chia Grafana Dashboard

Once your dashboard is running, knowing which panels to pay attention to makes all the difference. Here are the most important metrics and what they mean for your farm’s health.

Harvester Lookup Time is the most critical metric to watch. As discussed earlier, lookups over 5 seconds risk missing signage points, and lookups over 30 seconds produce invalid proofs.² Your Grafana dashboard shows this as a time-series graph. A healthy farm has a flat, low line. Sudden spikes point to slow drives, a disk under heavy load, or a network bottleneck between your farmer and a remote harvester.

Plots Passing Filter tells you how many of your plots are being scanned each challenge round. Every 9.375 seconds, the Chia network broadcasts a challenge, and a random subset of your plots pass the plot filter and get checked for a proof.⁶ If this number drops unexpectedly, a harvester may have gone offline or lost connection to your farmer.

Sync Status shows whether your full node is synced to the blockchain tip. If your node falls out of sync, you are not farming competitively. Grafana makes this visible as a simple status indicator rather than something you have to check manually in the GUI.

Estimated Time to Win is a statistical estimate based on your total plot size versus the global netspace. It does not guarantee a win at that exact time, but a dramatic increase (say, from 10 hours to 50 hours) indicates your plot count dropped or the network grew significantly.

XCH Wallet Balance and recent transaction history let you confirm that earned rewards are landing in your wallet as expected — useful for catching issues with pool payouts or farming rewards without having to open the GUI manually.

System Metrics (via node-exporter) include CPU usage, RAM, disk I/O, and storage utilization. These come from the Prometheus node-exporter sidecar rather than chia-exporter itself. They are essential for catching a drive that is nearly full, a CPU bottleneck caused by compressed plot decompression, or a failing disk causing slow I/O before it causes missed proofs.

Case Studies: When Monitoring Saves Rewards

Multiple Chia farmers in the official GitHub discussions have reported farming for over 120 hours without a single win — only to discover via log analysis that their harvesters were regularly exceeding the 30-second proof deadline, making every response invalid.⁷ A Grafana dashboard with an alert threshold on lookup time would have surfaced this issue within minutes of it starting.

Similarly, a farmer running multiple JBODs on a single node reported in an official Chia GitHub Discussion that one failing drive caused lookup times to reach 437 seconds — and because the harvester waits for every disk to return before responding, all plots became effectively unreachable until the bad drive was removed.¹³ Real-time monitoring turns this from a discovered-too-late disaster into an alert you fix the same day.

Connecting Monitoring to Smarter Chia Development

If you are building on Chia using Chialisp smart contracts, monitoring is not just about farming efficiency — it is about node reliability. A Chialisp-powered application depends on your full node staying synced and healthy. Monitoring your node’s RPC health, mempool state, and block validation time through Grafana gives you the infrastructure visibility you need to build confidently. To learn more about what Chialisp can do for your blockchain applications, see our deep dive on Chialisp: Transforming Blockchain & Unlocking Next-Gen Smart Contracts.

You can also pair your monitoring with a solid understanding of how Chia’s block rewards and farming economics work. Our guide on Chia Network Block Reward and Plot Filter Reductions explains how the 2024 plot filter halving doubled harvester workloads — making lookup time monitoring even more critical than it was before.

Conclusion

Running a Chia farm without monitoring is like driving without a dashboard — technically possible, but you will not know there is a problem until it is too late. Setting up Chia monitoring with Grafana and Prometheus gives you real-time visibility into the metrics that actually determine whether your farm is earning rewards or quietly losing them. The setup takes an afternoon, the pre-built dashboards mean you do not start from zero, and the payoff — catching a slow drive or a dropped harvester before it costs you XCH — is immediate. Start with chia-exporter, connect it to Prometheus, import dashboard ID 16456 or 17939 into Grafana, and you will have one of the most powerful farm monitoring setups in the Chia community. Your rewards depend on it.

Chia Monitoring Grafana FAQs

What is chia monitoring with Grafana and how does it work?

Chia monitoring with Grafana is a setup where the official chia-exporter reads metrics from your Chia node’s RPC services and passes them to Prometheus, which stores them as time-series data. Grafana then connects to Prometheus and displays those metrics as live charts and gauges. The result is a real-time visual dashboard for your entire Chia farm — including plot counts, harvester lookup times, XCH balance, and node sync status — all in one screen.

What Grafana dashboard ID should I use for chia monitoring grafana?

For chia monitoring with Grafana, the most widely used dashboard IDs are 17939 (Official Chia Farming, by Chia Network) and 16456 (Chia Farm Dashboard, supports multiple harvesters). If you run a large farm with five or more separate harvesters, dashboard ID 20070 (Multi-Harvester Version) is purpose-built for that setup.

Do I need Docker to run Grafana monitoring for Chia?

Docker is not required, but it makes setup significantly easier. Projects like chiamon offer a single docker-compose file that runs chia-exporter, Prometheus, Loki, and Grafana together. On Linux (Ubuntu), you can also install each component natively using apt and systemd — just follow the official chia-exporter installation guide from Chia Network’s GitHub repository.

Why is harvester lookup time the most important metric in Chia monitoring?

The Chia network broadcasts a block challenge every 9.375 seconds. If your harvester takes more than 30 seconds to respond with a proof, that proof is invalid and earns no reward. Chia’s own documentation recommends keeping maximum lookup times below five seconds to minimize the risk of missing signage points. Grafana’s time-series graph for lookup time makes slow drives or network bottlenecks immediately visible.

Can I monitor multiple Chia harvesters with a single Grafana dashboard?

Yes. Running chia-exporter on each harvester machine and adding all of their endpoints as separate scrape targets in your Prometheus configuration lets you collect metrics from every harvester centrally. Grafana dashboard ID 16456 and 20070 both support multi-harvester setups and include per-harvester breakdown panels for lookup times, plot counts, and proof attempts.

Chia Monitoring Grafana Citations

1. Chia Network. chia-exporter: RPC/WebSocket based metrics exporter for Chia. GitHub. https://github.com/Chia-Network/chia-exporter
2. Chia Network. Choosing a Compression Level — Harvester Lookup Times. Chia Documentation. https://docs.chia.net/reference-client/plotting/plotting-compression/
3. Grafana Labs. Chia Farm Dashboard. Grafana Dashboard ID 16456. https://grafana.com/grafana/dashboards/16456-chia-farm-dashboard/
4. Chia Decentral. Chia Farming Dashboard — Docker Setup Guide. https://chiadecentral.com/chia-farming-dashboard/
5. Chia Network. Announcing Chia Dashboards. Chia Network Blog, April 2022. https://www.chia.net/2022/04/06/announcing-chia-dashboards/
6. Chia Network. Harvester Algorithm. Chia Documentation. https://docs.chia.net/chia-blockchain/consensus/chains/harvester-algorithm/
7. Chia Network Community. Nothing Tells You When You’re Timing Out on 30-Second Harvester Proof Checks. GitHub Issues #2651. https://github.com/Chia-Network/chia-blockchain/issues/2651
8. Prometheus. Overview — Prometheus Monitoring System. https://prometheus.io/docs/introduction/overview/
9. Prometheus. Getting Started with Prometheus. https://prometheus.io/docs/tutorials/getting_started/
10. Prometheus. Prometheus Reliability Design — Standalone Operation. Prometheus Documentation. https://prometheus.io/docs/introduction/comparison/
11. Stefan Lange. chia-farm-dashboard: Grafana Dashboard for Different Chia Metrics. GitHub. https://github.com/stefan-lange/chia-farm-dashboard
12. Kevin Retzke. chiamon: Example Chia Monitoring Stack. GitHub. https://github.com/retzkek/chiamon
13. Chia Network Community. Farmer/Harvester Proof Checks Should Timeout — JBOD Disk Causing Full Harvester Timeout. GitHub Discussion #11302. https://github.com/Chia-Network/chia-blockchain/discussions/11302