How to Monitor Your Miners Programmatically with the NoxHash API

Why Monitor Your Miners With an API Instead of the Dashboard

The NoxHash web dashboard is built for humans: you log in, glance at hashrate and BTC balance, and log out. That works for one or two miners. Once you run multiple rentals — or you want alerts when something goes wrong at 3 a.m. — you need a machine watching for you.

An API monitor sits outside the dashboard and pulls the same data on a schedule. It can log earnings to a spreadsheet, push metrics into Grafana, or text you the moment a miner drops offline. You own the logic, so you decide exactly when to get notified and what counts as "a problem."

Step 1 — Create an API Key in Your NoxHash Account

Every API call needs an authenticated identity. NoxHash issues personal API keys from your account settings, and you can set an expiry date so a leaked key stops working automatically.

Step 2 — A Minimal Python Monitor (Pseudo-code)

Here is a small, readable Python script that authenticates, fetches your miners, and flags any that have been offline for more than 30 minutes. It is deliberately simple — no dependencies beyond requests — so you can drop it into a cron job today and harden it tomorrow.

import os, time, requests
from datetime import datetime, timedelta, timezone

API_BASE = "https://api.noxhash.com/v1"   # confirm in current docs
API_KEY  = os.environ["NOXHASH_API_KEY"]  # never hard-code
OFFLINE_THRESHOLD = timedelta(minutes=30)

headers = {
    "Authorization": f"Bearer {API_KEY}",
    "Accept": "application/json",
}

def fetch_miners():
    r = requests.get(f"{API_BASE}/miners", headers=headers, timeout=10)
    r.raise_for_status()
    return r.json().get("data", [])

def check_offline(miners):
    now = datetime.now(timezone.utc)
    alerts = []
    for m in miners:
        if m["status"] != "running":
            last_seen = datetime.fromisoformat(m["last_seen_at"])
            if now - last_seen > OFFLINE_THRESHOLD:
                alerts.append(m)
    return alerts

def send_sms(miner):
    # plug in Twilio / Vonage / a webhook to your phone
    print(f"ALERT: {miner['name']} offline since {miner['last_seen_at']}")

if __name__ == "__main__":
    while True:
        try:
            for miner in check_offline(fetch_miners()):
                send_sms(miner)
        except requests.HTTPError as e:
            print(f"API error: {e}")
        time.sleep(300)  # poll every 5 minutes — be kind to the API

Prefer JavaScript? The same shape works with fetch in a Node.js script, scheduled with a cron runner or a serverless scheduler. The logic is identical: authenticate, list miners, filter by status and timestamp, notify.

const API_BASE = "https://api.noxhash.com/v1";
const API_KEY  = process.env.NOXHASH_API_KEY;
const OFFLINE_MS = 30 * 60 * 1000;

async function fetchMiners() {
  const res = await fetch(`${API_BASE}/miners`, {
    headers: { Authorization: `Bearer ${API_KEY}` },
  });
  if (!res.ok) throw new Error(`HTTP ${res.status}`);
  const { data } = await res.json();
  return data;
}

function offlineAlerts(miners) {
  const now = Date.now();
  return miners.filter(m =>
    m.status !== "running" &&
    now - new Date(m.last_seen_at).getTime() > OFFLINE_MS
  );
}

setInterval(async () => {
  try {
    const alerts = offlineAlerts(await fetchMiners());
    alerts.forEach(m => console.log(`ALERT: ${m.name} offline`));
  } catch (e) { console.error(e.message); }
}, 5 * 60 * 1000);

Three Use Cases Worth Building First

You don't need to build everything on day one. Pick one of these and ship it this weekend — each is small enough for an evening and genuinely useful on Monday morning.

Polling vs Webhooks — Which Pattern Fits?

Polling means your script asks the API "what's new?" on a timer. Webhooks reverse the flow: NoxHash pushes events to a URL you host. Both have a place. If the API currently supports webhooks for the events you care about, they are cheaper and faster; if not, a polite polling loop works fine.

A hybrid is often the right answer: webhooks for critical alerts (miner offline, rental near expiry), polling for periodic summaries (daily earnings log, weekly report). Pick based on which events the API surfaces and how tolerant you are of a 1 to 5 minute delay.

Rate-Limit Etiquette and Key Hygiene

An API you abuse is an API you lose. NoxHash, like every serious platform, enforces rate limits and may temporarily block keys that behave badly. A few habits keep your integration welcome and your account safe.

Frequently Asked Questions