Check your AI API balances every morning: HeyGen, ElevenLabs and Anthropic in one Node script, before a render dies mid-week

An AI content pipeline rarely breaks on a bug. It breaks on a Tuesday when a wallet hits zero and every render after that fails. My HeyGen account is a prepaid wallet with auto-reload off, so that's a real risk every week. The morning I wrote this, it read $6.83, about 0.2 weeks of runway at my normal spend.

The annoying part is that every tool keeps its balance somewhere different. HeyGen gives you dollars, ElevenLabs gives you characters, and Anthropic doesn't give a standard API key a balance at all. This guide is the script that reads all three every morning and tells you before anything breaks. I've run a version of it daily since 27 August 2026.

What you'll have when you're done

• One Node script that prints a status line for HeyGen, ElevenLabs and Anthropic
• Each balance turned into weeks of runway, not a raw number
• An exit code a scheduler can act on: 0 when everything is funded, 1 when something needs you
• An alert rule that only messages you when something changed
• [SCREENSHOT: terminal output, three status lines, one "warn"]

Before you start

• Node.js 20 or newer, for built-in fetch and --env-file.
• Your API keys in a .env file: HEYGEN_API_KEY, ELEVENLABS_API_KEY, ANTHROPIC_API_KEY. Never paste them into the script.
• Your normal weekly spend per tool, roughly. The script compares against it.
• About 30 minutes.

There's no download pack for this one. The script is on the page.

Step 1: Know where each balance lives

Read 6 November 2026 from each vendor's docs:

HeyGen      GET https://api.heygen.com/v3/users/me
            header X-Api-Key, prepaid accounts get data.wallet.remaining_balance (USD)
            /v2/user/remaining_quota: v1/v2 sunset 31 Oct 2026, calls may fail

ElevenLabs  GET https://api.elevenlabs.io/v1/user/subscription
            header xi-api-key, returns character_count, character_limit,
            next_character_count_reset_unix

Anthropic   no balance endpoint for a standard API key
            Usage & Cost API = spend, needs an Admin key, not for individual accounts
            -> send a 1-token request; an empty account fails "credit balance is too low"

If you built against HeyGen's old quota endpoint, move now. HeyGen's own version table says v1 and v2 reached their sunset on 31 October 2026 and calls may fail intermittently while removal is in progress.

Step 2: Run the script

Save this as balances.mjs. Set WEEKLY_HEYGEN_USD to what you spend in a normal week.

// node --env-file=.env balances.mjs  -> one line per API, exit 1 if anything needs you
const { HEYGEN_API_KEY, ELEVENLABS_API_KEY, ANTHROPIC_API_KEY } = process.env;
const WEEKLY_HEYGEN_USD = 30; // what you spend in a normal week

async function heygen() {
  const r = await fetch("https://api.heygen.com/v3/users/me", {
    headers: { "X-Api-Key": HEYGEN_API_KEY },
  });
  if (!r.ok) return ["dead", `HTTP ${r.status}`];
  const w = (await r.json())?.data?.wallet;
  if (!w) return ["unknown", "no wallet on this account (subscription billing?)"];
  const usd = Number(w.remaining_balance);
  const reload = Boolean(w.auto_reload?.enabled);
  const weeks = (usd / WEEKLY_HEYGEN_USD).toFixed(1);
  const status = reload ? "ok" : usd < WEEKLY_HEYGEN_USD ? "warn" : "ok";
  return [status, `$${usd.toFixed(2)}, auto-reload ${reload ? "on" : "off"}, ~${weeks} weeks`];
}

async function elevenlabs() {
  const r = await fetch("https://api.elevenlabs.io/v1/user/subscription", {
    headers: { "xi-api-key": ELEVENLABS_API_KEY },
  });
  if (r.status === 401) {
    const body = await r.json().catch(() => ({}));
    if (body?.detail?.status === "missing_permissions")
      return ["blind", "key can't read the account: enable User read on this key"];
    return ["dead", "key rejected"];
  }
  if (!r.ok) return ["unknown", `HTTP ${r.status}`];
  const s = await r.json();
  const left = s.character_limit - s.character_count;
  const reset = s.next_character_count_reset_unix
    ? new Date(s.next_character_count_reset_unix * 1000).toISOString().slice(0, 10)
    : "?";
  const status = left / s.character_limit < 0.2 ? "warn" : "ok";
  return [status, `${left.toLocaleString("en-US")} of ${s.character_limit.toLocaleString("en-US")} left, resets ${reset}`];
}

// No balance endpoint for a standard key, so make the smallest real call.
async function anthropic() {
  const r = await fetch("https://api.anthropic.com/v1/messages", {
    method: "POST",
    headers: {
      "x-api-key": ANTHROPIC_API_KEY,
      "anthropic-version": "2023-06-01",
      "content-type": "application/json",
    },
    body: JSON.stringify({
      model: "claude-haiku-4-5-20251001",
      max_tokens: 1,
      messages: [{ role: "user", content: "hi" }],
    }),
  });
  if (r.ok) return ["ok", "probe accepted, account funded"];
  const text = await r.text();
  if (/credit balance is too low/i.test(text)) return ["critical", "OUT OF CREDIT"];
  if (r.status === 429) return ["ok", "rate-limited, billing is fine"];
  return ["unknown", `HTTP ${r.status}`];
}

const checks = { heygen, elevenlabs, anthropic };
let bad = 0;
for (const [name, fn] of Object.entries(checks)) {
  const [status, detail] = await fn().catch((e) => ["unknown", e.message]);
  if (status !== "ok") bad++;
  console.log(`${status.padEnd(8)} ${name.padEnd(11)} ${detail}`);
}
process.exit(bad ? 1 : 0);

node --env-file=.env balances.mjs

Here's what it printed on my machine on 6 November 2026:

warn     heygen      $6.83, auto-reload off, ~0.2 weeks
ok       elevenlabs  181,031 of 233,320 left, resets 2026-11-20
ok       anthropic   probe accepted, account funded

Step 3: Fix the ElevenLabs blind spot

ElevenLabs lets you restrict which endpoints a key can reach, which is good practice for a key that only makes speech. The catch is that a restricted key can't read the account. The subscription endpoint answers 401 with missing_permissions, and a careless check reads that as a dead key.

My key did exactly this in August 2026. The fix is to edit the existing key on ElevenLabs and allow it to read user data. Nothing else about the key changes. The script reports this case as blind, not dead, so you know the key still works for speech.

Step 4: Check Anthropic the only way that works

There's no balance call for a standard API key, so the script makes the cheapest real request: one output token on the smallest model. If the account is funded, it goes through. If it's empty, it fails with a "credit balance is too low" error, which is the exact failure you want to catch the morning it starts. A 429 means you're rate-limited, which is a throughput problem, not a funding one.

While you're in the Anthropic console, check whether your billing has automatic top-up turned on. If it does, this line will rarely matter.

Step 5: Turn balances into runway

I think a raw balance doesn't tell you when to act. Weeks of runway does. The script divides the HeyGen wallet by your weekly spend; do the same for anything else you track.

Thresholds I use
critical  this week will break       (wallet under ~1/3 of a week's spend, or a dead key)
warn      under one week of runway   (wallet under one week's spend)
ok        a week or more, or auto-reload on
ElevenLabs: warn under 20% of the monthly characters left

Tools with no API for their balance go on the list anyway. Higgsfield is one in my stack: I read its credits by hand, or through its connector inside a Claude session, and pass the number to the check.

Step 6: Schedule it and alert only on change

Run it once every morning: Windows Task Scheduler, a cron job, or a scheduled Claude task. Mine runs at 09:30 with my other session checks.

The rule I think keeps it useful: alert only when the set of problems changes, then re-alert every 24 hours for something broken and every 72 hours for a warning. A check that emails you daily about the same warning gets ignored, and then it misses the day that matters. Save the last alert and its time in a small JSON file and compare before sending.

Alert rule
problems = sorted list of "tool:status" that aren't ok
if problems is empty            -> no alert (and clear the saved state)
if problems != last saved       -> alert now
if broken and 24h since alert   -> alert again
if warning and 72h since alert  -> alert again

The honest part about this check

I think the limit is worth saying plainly: it only sees what each vendor exposes. HeyGen's wallet is exact, ElevenLabs is exact once the key can read it, and Anthropic is only "funded or not", never how much. For the full picture you still log in to the consoles.

And it can't top anything up. Paying is a human step, and I think it should stay one.

What I'd do differently

Move off sunset endpoints before the date. The HeyGen v2 quota call was announced well ahead.

Treat 401 with a reason as different from 401. "Can't read the balance" and "dead key" need different fixes.

Alert on change, not on state. That's what keeps you reading the alerts.

Turn auto-reload on where it exists. The best alert is the one that never fires.