DEV Community: Synergic-Apis

US national debt API: daily to the penny + every year since 1790

Synergic-Apis — Wed, 05 Aug 2026 09:35:08 +0000

The US national debt is published by the U.S. Treasury as the "Debt to the Penny" dataset — one exact figure per business day, literally to the cent. This guide shows you how to get today's number, the full daily series since 1993, and the annual debt outstanding for every fiscal year since 1790 (yes, the whole 235-year story in one API call) — on a free key with 500 requests/month and no credit card.

The three official series, as one JSON API

The US National Debt API wraps the official U.S. Treasury Fiscal Data into clean, versioned JSON:

Debt to the Penny — total public debt outstanding for every business day since 1993-04-01, split into debt held by the public and intragovernmental holdings. Amounts are JSON numbers, exact to the cent as published (round-trip verified against the full dataset).
Historical Debt Outstanding — the debt at each fiscal year end since 1790. The fiscal year end has moved through history (calendar year through 1842, June 30 through 1976, September 30 since 1977 — and fiscal 1843 has two closes, both served); the API gives you the real close dates.
Average Interest Rates — what the Treasury actually pays on the debt, monthly since 2001, across eight security classes (total, marketable, non-marketable, bills, notes, bonds, tips, frn).

Data refreshes automatically every day after the Treasury publishes (each business day's figure lands the following business day around 3:00 PM ET). A nice property of this dataset: the source never froze during federal government shutdowns — verified through the Oct–Nov 2025 shutdown.

Get a key and make the first call

curl -s "https://api.synergicapis.com/debt/latest" \
  -H "X-Api-Key: YOUR_API_KEY"

Response (example data — the real call returns the most recent published business day):

{
  "data": {
    "period": "2026-07-20",
    "total": 39588242618845.71,
    "held_by_public": 31817640840048.45,
    "intragovernmental": 7770601778797.26,
    "unit": "US dollars",
    "source": "US Treasury"
  },
  "meta": { "source": "U.S. Treasury Fiscal Data", "area": "us" }
}

That .71 at the end is not a rounding artifact — it's the Treasury's published figure, to the penny.

Endpoints

Endpoint	What it returns
`GET /debt/latest`	The national debt today, to the penny
`GET /debt/history`	Daily records since 1993, paginated (`start`, `end`, `limit` ≤ 100)
`GET /debt/annual`	Fiscal-year-end debt since 1790 (`limit=250` = whole series in one call)
`GET /debt/interest-rates`	Latest average interest rate of each of the 8 security classes
`GET /debt/interest-rates/{class}/history`	Monthly rate history of one class (2001+)
`GET /health`	Liveness check (not rate limited)

Dates are real YYYY-MM-DD dates. Pagination is keyset: pass each page's meta.next_end as the next end; it's null on the last page.

The 1790 series in one request

This is the endpoint that makes historians happy. With limit=250, the annual endpoint returns the complete series — no pagination loop needed:

curl -s "https://api.synergicapis.com/debt/annual?limit=250" \
  -H "X-Api-Key: YOUR_API_KEY"

{
  "data": [
    { "period": "2025-09-30", "value": 37637553494935.61, "unit": "US dollars", "source": "US Treasury" },
    { "period": "2024-09-30", "value": 35464673929171.69, "unit": "US dollars", "source": "US Treasury" }
  ],
  "meta": { "source": "U.S. Treasury Fiscal Data", "area": "us", "count": 2, "next_end": "2024-09-29" }
}

(Example shows the first two records; the real call returns every fiscal year back to 1790.)

Python: daily history with pagination

import requests

BASE = "https://api.synergicapis.com"
HEADERS = {"X-Api-Key": "YOUR_API_KEY"}

def daily_debt(start="2026-01-01"):
    records, end = [], None
    while True:
        params = {"start": start, "limit": 100}
        if end:
            params["end"] = end
        r = requests.get(f"{BASE}/debt/history", headers=HEADERS, params=params)
        r.raise_for_status()
        body = r.json()
        records.extend(body["data"])
        end = body["meta"]["next_end"]
        if end is None:
            return records

ytd = daily_debt("2026-01-01")
delta = ytd[0]["total"] - ytd[-1]["total"]
print(f"Debt change since Jan 1: ${delta:,.2f}")

Note: the held_by_public / intragovernmental components are null before 2005-03-31 — the source didn't break them out back then. The API serves the record as published rather than inventing a split.

JavaScript: a live "debt clock" number

const BASE = "https://api.synergicapis.com";

const res = await fetch(`${BASE}/debt/latest`, {
  headers: { "X-Api-Key": "YOUR_API_KEY" },
});
const { data } = await res.json();

const formatted = data.total.toLocaleString("en-US", {
  style: "currency",
  currency: "USD",
});
console.log(`US national debt as of ${data.period}: ${formatted}`);

Responses are cacheable (ETag/If-None-Match → 304) and carry RateLimit-* headers, so a widget that refreshes once a day costs you ~30 requests a month — 6% of the free tier.

What the debt costs: interest rates

The underrated series. GET /debt/interest-rates returns the latest average rate per security class:

{
  "data": [
    { "class": "total", "period": "2026-06-30", "rate": 3.409, "unit": "percent", "source": "US Treasury" },
    { "class": "bills", "period": "2026-06-30", "rate": 3.706, "unit": "percent", "source": "US Treasury" },
    { "class": "bonds", "period": "2026-06-30", "rate": 3.43, "unit": "percent", "source": "US Treasury" }
  ],
  "meta": { "source": "U.S. Treasury Fiscal Data", "area": "us" }
}

Combine total debt × total average rate and you have a back-of-the-envelope annual interest bill — a chart that basically writes its own blog post. To put the debt in real terms, the same platform offers a US Inflation API with CPI back to 1913 — the same key covers both APIs — so you can deflate the 1790–today series properly instead of comparing nominal dollars across centuries. (Step-by-step guide: How to get US inflation data by API.)

Pricing

Free tier: 500 req/month, no credit card — enough for a daily-refresh dashboard many times over. Paid plans at synergicapis.com: PRO $7.99/mo (50k), ULTRA $24.99/mo (500k), BUSINESS $79/mo (5M). Official data, versioned JSON, uniform error contract (NO_DATA, VALIDATION_ERROR, RATE_LIMITED...).

FAQ

What is the US national debt right now?
GET /debt/latest returns the most recent Treasury-published figure to the penny — in the example data above, $39,588,242,618,845.71 as of 2026-07-20. Each business day's figure is published the next business day around 3:00 PM ET.

How far back does the data go?
Daily: every business day since 1993-04-01. Annual: every fiscal year end since 1790 — and limit=250 fits the entire series in a single response.

What's the difference between "debt held by the public" and "intragovernmental holdings"?
The total splits into debt held by outside investors (public) and debt one part of the government owes another (e.g. trust funds). Both components come on every daily record from 2005-03-31 onward; before that the source didn't publish the split, so they're null.

Is this official data?
Yes — the source is U.S. Treasury Fiscal Data (an unrestricted license), refreshed daily. This is an independent product, not endorsed by or affiliated with the U.S. Department of the Treasury.

Source: U.S. Treasury Fiscal Data. This product is independent and not endorsed by or affiliated with the U.S. Department of the Treasury.

How to get US inflation data by API — CPI since 1913 (2026 guide)

Synergic-Apis — Sun, 02 Aug 2026 18:29:52 +0000

If you need US inflation data in your app, the official source is the Consumer Price Index (CPI-U) published monthly by the Bureau of Labor Statistics — and the fastest way to consume it is a JSON API that already computes the year-over-year and month-over-month rates for you. In this guide you'll query the latest CPI for 11 categories, pull monthly history back to 1913, and download the full annual series in a single call — all on a free API key (500 requests/month, no credit card).

What "US inflation" actually means (and why the raw BLS data is painful)

When the press says "inflation was 3.5% in June", they mean the year-over-year change of the CPI-U index, not seasonally adjusted (NSA). The month-over-month figure, on the other hand, is conventionally quoted seasonally adjusted (SA). Two different series, two different conventions — and the BLS distributes them as index levels, not rates, so you have to compute the percentages yourself, rounding to 1 decimal exactly the way the BLS does or your numbers won't match the headlines.

The US Inflation API does that work server-side. It serves the official CPI-U (U.S. city average) as clean, versioned JSON:

11 categories: all-items (headline), core, energy, food, housing, apparel, transportation, medical, recreation, education-communication, other
Both NSA and seasonally adjusted variants (adjusted=true|false)
YoY and MoM rates precomputed from the index, 1 decimal, matching the BLS methodology
Monthly history back to 1913 for the headline, plus the official annual averages (the M13 rows)
A bonus: the famous average price basket in dollars — eggs, gasoline, milk, bread, ground beef, coffee, electricity

Data refreshes automatically on each monthly CPI release (8:30 AM ET, scheduled days 10–18 of the following month). Everything is a JSON number — no strings pretending to be numbers.

Get a free API key

Sign up at synergicapis.com — the free tier is 500 requests/month, no credit card.
Grab your key and send it in the X-Api-Key header.

That's it. First call:

curl -s "https://api.synergicapis.com/inflation/latest" \
  -H "X-Api-Key: YOUR_API_KEY"

Response (example data — the real call returns the latest published month):

{
  "data": [
    {
      "category": "all-items",
      "adjusted": false,
      "period": "2026-06",
      "index": 333.952,
      "yoy_pct": 3.5,
      "mom_pct": -0.3,
      "source": "BLS"
    },
    {
      "category": "core",
      "adjusted": false,
      "period": "2026-06",
      "index": 336.882,
      "yoy_pct": 2.7,
      "mom_pct": 0,
      "source": "BLS"
    }
  ],
  "meta": { "source": "U.S. Bureau of Labor Statistics", "area": "us" }
}

That single response is the whole "inflation report table": every category, latest month, rates included.

Endpoints

Endpoint	What it returns
`GET /inflation/latest`	Latest CPI point of all 11 categories (the report table)
`GET /inflation/{category}`	Latest point of one category
`GET /inflation/{category}/history`	Monthly history (headline since 1913), paginated
`GET /inflation/{category}/annual`	Official annual averages (headline since 1913)
`GET /prices`	Latest US average price of eggs, gasoline, milk, bread, ground beef, coffee, electricity
`GET /prices/{item}/history`	Monthly price history of one item (gasoline since 1976)
`GET /health`	Liveness check (not rate limited)

Common query params: adjusted=true|false (default false = NSA, the YoY convention), start/end (YYYY-MM), limit (1–100 for monthly, up to 150 for annual).

Python: the full history since 1913

Pagination is keyset-based: each page's meta.next_end is the end you pass for the next page; it's null on the last page. This loop pulls every monthly headline point since 1913:

import requests

BASE = "https://api.synergicapis.com"
HEADERS = {"X-Api-Key": "YOUR_API_KEY"}

def full_history(category="all-items"):
    points, end = [], None
    while True:
        params = {"limit": 100}
        if end:
            params["end"] = end
        r = requests.get(f"{BASE}/inflation/{category}/history",
                         headers=HEADERS, params=params)
        r.raise_for_status()
        body = r.json()
        points.extend(body["data"])
        end = body["meta"]["next_end"]
        if end is None:
            return points

history = full_history()
print(len(history), "monthly points, oldest:", history[-1]["period"])

If you only need annual data, one call is enough — limit=150 returns the complete official annual-average series in a single page:

r = requests.get(f"{BASE}/inflation/all-items/annual",
                 headers=HEADERS, params={"limit": 150})
annual = r.json()["data"]   # 1913 ... today, done

Example annual point, straight from the official M13 rows:

{ "category": "all-items", "period": "2025", "index": 321.348, "source": "BLS" }

JavaScript: current inflation rate in 10 lines

const BASE = "https://api.synergicapis.com";

const res = await fetch(`${BASE}/inflation/all-items`, {
  headers: { "X-Api-Key": "YOUR_API_KEY" },
});
const { data } = await res.json();

console.log(
  `US inflation (${data.period}): ${data.yoy_pct}% YoY, ${data.mom_pct}% MoM`
);
// e.g. "US inflation (2026-06): 3.5% YoY, -0.3% MoM"  (example data)

Want the seasonally adjusted variant (the one used for month-over-month analysis)? Add ?adjusted=true.

Good to know: the honest edge cases

October 2025 does not exist. The BLS never published that month (federal shutdown). It's a real hole in the official record — this API serves it as a hole, not an interpolation. Rates that need it (Nov-2025 MoM, Oct-2026 YoY) come back as null, never invented.
Rates can be null at series starts for the same reason: no mirror month, no rate.
Responses are cacheable (Cache-Control, ETag/If-None-Match → 304) and include RateLimit-* budget headers, so a well-behaved client can poll cheaply. A 429 includes Retry-After.
Errors follow one uniform contract: { "error": { "code": "...", "message": "..." } } with stable codes like CATEGORY_NOT_FOUND or VALIDATION_ERROR.

Pricing

The free tier (500 req/month, no card) covers a dashboard that refreshes on release day with room to spare. Paid plans on synergicapis.com: PRO $7.99/mo (50k req), ULTRA $24.99/mo (500k), BUSINESS $79/mo (5M). Official data, versioned JSON, free tier — no scraping, no CSV parsing.

If you're building a macro dashboard, the same platform also serves the US National Debt API — daily to the penny, with history back to 1790 — same JSON conventions, and the same key covers both APIs.

FAQ

What is the current US inflation rate?
The year-over-year change of the CPI-U all-items index (NSA), published monthly by the BLS. GET /inflation/all-items returns it precomputed — in the example data above, 3.5% for 2026-06. One request, one number.

How far back does CPI data go?
The headline (all-items) series starts in 1913, both monthly and as official annual averages. Other categories start later. GET /inflation/all-items/annual?limit=150 returns the entire annual series in one call.

Is this the official BLS data?
Yes — the source is the U.S. Bureau of Labor Statistics CPI-U (U.S. city average), refreshed on each monthly release, and every number traces to a named BLS series: the CPI-U index family (headline CUUR0000SA0) and the Average Price series for the dollar basket. The exact series IDs per endpoint are listed in the API's data provenance section. The API computes rates the same way the BLS does (1 decimal). It is an independent product, not affiliated with the BLS.

What's the difference between adjusted=true and adjusted=false?
false (default) is not seasonally adjusted — the convention for year-over-year figures the press quotes. true is seasonally adjusted — the convention for month-over-month analysis.

Source: U.S. Bureau of Labor Statistics. This product is independent and not endorsed by or affiliated with the BLS.

yfinance NG=F Not Working? Why Natural Gas Futures Data Fails and 3 Fixes That Work

Synergic-Apis — Fri, 31 Jul 2026 09:44:20 +0000

If your script suddenly started printing this:

>>> import yfinance as yf
>>> df = yf.download("NG=F", period="1mo")

1 Failed download:
['NG=F']: YFPricesMissingError('possibly delisted; no price data found')

…you didn't break anything. NG=F (the natural gas futures ticker on Yahoo Finance) periodically stops returning data for everyone, and futures tickers get hit harder than stocks. This post covers why it happens and the three fixes that actually work, ordered from "quick patch" to "never deal with this again."

1. What the error actually means

yfinance is not an official API. It's a (great) community library that scrapes Yahoo Finance's internal endpoints — the same ones Yahoo's own website uses. Yahoo doesn't document them, doesn't promise they'll keep working, and changes them whenever it suits their frontend.

When Yahoo changes something — an endpoint, a rate limit, a response format — yfinance breaks until its maintainers reverse-engineer the change. Futures symbols like NG=F and GC=F are the most fragile: they've had recurring gaps and failures reported over the years, for example #2620 (missing recent data for NG=F/GC=F), #2635 (whole missing days in futures history) and the evergreen #865 "Futures only work sometimes".

So: "possibly delisted" almost never means delisted. It means "the scrape came back empty."

2. Fix #1 — the quick patches (works today, breaks tomorrow)

Three things fix most transient failures:

Upgrade first. The maintainers usually patch Yahoo changes within days:

pip install -U yfinance

Retry with backoff. Failures are often intermittent rate-limiting, not hard breaks:

import time
import yfinance as yf

def download_with_retry(ticker, retries=3, wait=5, **kwargs):
    for attempt in range(1, retries + 1):
        df = yf.download(ticker, progress=False, **kwargs)
        if not df.empty:
            return df
        print(f"attempt {attempt} came back empty, retrying in {wait}s…")
        time.sleep(wait * attempt)
    raise RuntimeError(f"{ticker}: no data after {retries} attempts")

df = download_with_retry("NG=F", period="1mo")

Try the other code path. yf.download() and yf.Ticker().history() don't always behave identically for futures (see #1036):

df = yf.Ticker("NG=F").history(period="1mo")

If none of that works, it's a real breakage — wait for a patch, or keep reading.

3. Why it will keep breaking

This isn't a bug you fix once. It's structural:

Unofficial: Yahoo owes yfinance nothing, and scraping is against Yahoo's terms of service — which also means you can't legitimately ship yfinance data inside a commercial product.
Futures are second-class: most of Yahoo's traffic is stocks; futures endpoints get less love and break more.
Your pipeline inherits the risk: if a cron job, dashboard or trading signal depends on NG=F, every silent Yahoo change is now your incident.

For a weekend backtest, that trade-off is fine. For anything that runs unattended every day, you eventually want a data source whose job is to keep answering.

4. Fix #2 — a drop-in replacement (one line to migrate)

I got tired of this cycle and moved my pipelines to a dedicated natural gas price API. The function below returns a DataFrame shaped like what you're used to (date index, Close column), so migrating is one line:

import requests
import pandas as pd

RAPIDAPI_KEY = "YOUR_RAPIDAPI_KEY"  # free key, no card: see link at the end

def get_natural_gas(start=None, end=None):
    """Drop-in replacement for yf.download('NG=F'):
    returns a DataFrame indexed by date with a Close column."""
    url = "https://natural-gas-price-api.p.rapidapi.com/historical"
    headers = {
        "X-RapidAPI-Key": RAPIDAPI_KEY,
        "X-RapidAPI-Host": "natural-gas-price-api.p.rapidapi.com",
    }
    params = {}
    if start:
        params["start"] = start
    if end:
        params["end"] = end
    r = requests.get(url, headers=headers, params=params, timeout=10)
    r.raise_for_status()
    rows = r.json()["data"]
    df = pd.DataFrame(rows).rename(columns={"date": "Date", "price": "Close"})
    df["Date"] = pd.to_datetime(df["Date"])
    return df.set_index("Date").sort_index()

# before:
# df = yf.download("NG=F", start="2025-01-01")
# after:
df = get_natural_gas(start="2025-01-01")

One honest nuance before you swap blindly: NG=F is the front-month futures contract; a price API typically serves the spot price (e.g. Henry Hub). They track each other closely but are not the same number — spot is the right series for "what does gas cost today" analytics and dashboards, while futures matter if you're modeling contract roll or term structure. Know which one your use case needs.

5. Fix #3 — the free official source (EIA), if you only need US history

Full honesty: if all you need is official US historical data and you don't mind some assembly, the U.S. Energy Information Administration gives it away for free. Register for a key at eia.gov/opendata, then:

import requests
import pandas as pd

EIA_KEY = "YOUR_FREE_EIA_KEY"

url = "https://api.eia.gov/v2/natural-gas/pri/fut/data/"
params = {
    "api_key": EIA_KEY,
    "frequency": "daily",
    "data[0]": "value",
    "facets[series][]": "RNGWHHD",  # Henry Hub daily spot
    "sort[0][column]": "period",
    "sort[0][direction]": "desc",
    "length": 5000,
}
resp = requests.get(url, params=params, timeout=30).json()
df = pd.DataFrame(resp["response"]["data"])[["period", "value"]]
df.columns = ["Date", "Close"]
df["Date"] = pd.to_datetime(df["Date"])
df = df.set_index("Date").sort_index()

The catches, so you're not surprised: data is published with a delay (it's a statistics agency, not a market feed), it's US-only (no European TTF), responses are capped at 5,000 rows per request, and the v2 route/facet system takes a while to learn. Great archival source; not a live one.

6. Choosing between the three

	yfinance (`NG=F`)	EIA Open Data	Dedicated API
What it is	Scraper of Yahoo's internal endpoints	Official US government statistics	Commercial API with a stable contract
Stability	Breaks when Yahoo changes things	Very stable	Uptime is the product
OK to ship in production?	No (unofficial, against ToS)	Yes (public domain)	Yes
Series	Front-month futures OHLC	Henry Hub spot + storage, US only	Spot + historical
Freshness	Near-real-time, when it works	Published with a lag	Frequent updates
Europe (TTF)	Fragile symbols at best	No	Yes
Effort	`pip install`	Key + learn v2 routes	Key + one GET
Cost	Free	Free	Free tier, paid for volume

7. The resilient version (primary + fallback)

What I actually run in daily jobs — a stable primary source with yfinance demoted to fallback duty:

"""Daily natural gas price fetch that doesn't die when Yahoo changes something."""
import sys

def fetch_price():
    try:
        df = get_natural_gas()  # primary: stable API (section 4)
        source = "natural-gas-price-api"
    except Exception as api_err:
        print(f"[warn] primary API failed: {api_err}", file=sys.stderr)
        try:
            import yfinance as yf
            df = yf.download("NG=F", period="5d", progress=False)
            if df.empty:
                raise ValueError("yfinance returned an empty frame")
            source = "yfinance (fallback)"
        except Exception as yf_err:
            raise RuntimeError(f"all sources failed: {api_err} / {yf_err}")
    print(f"latest close ({source}): {float(df['Close'].iloc[-1]):.3f}")
    return df

if __name__ == "__main__":
    fetch_price()

Two sources, loud warnings, no silent empty DataFrames poisoning your pipeline.

Full disclosure: the API used in sections 4 and 7 is mine — I built natural-gas-price-api after hitting exactly this problem. There's a free tier (no card required) if you want to try it, and the EIA route above is genuinely good if free official US history is all you need. Questions about data sourcing welcome in the comments.