Historical Fed Discount Rate (FED_DISCOUNT_RATE) Rates

Historical Fed Discount Rate (FED_DISCOUNT_RATE) Rates

You need reliable, programmatic access to the Federal Reserve’s Primary Credit Discount Rate for backtesting, risk models, and loan analytics. By the end of this guide you will pull multi-year historical time series for FED_DISCOUNT_RATE, compute spreads and monthly payments from returned values, build OHLC candlesticks for charting, and stand up a Python data pipeline that exports clean CSV/Parquet — all with straightforward GET requests to interestratesapi.com.

What the FED_DISCOUNT_RATE symbol represents and how it’s expressed

FED_DISCOUNT_RATE is the Federal Reserve’s Primary Credit Discount Rate published in USD. In the Interest Rates API, it is a central bank rate with daily frequency. The rate value is expressed as a percentage per annum (for example, a value of 4 means 4% p.a.).

Illustration: Historical Fed Discount Rate (FED_DISCOUNT_RATE) Rates

Every endpoint returns the effective date for the rate. When you query multiple dates, the timeseries will align to business days where data exists. Overnight/weekend/holiday gaps should be expected; the rate may remain unchanged across non-business days, so consecutive dates can share the same value.

Key fields to watch for when you parse responses:

  • rates: numeric percentage values (e.g., 4 means 4%).
  • dates: the effective date per symbol, used to confirm currency of each rate.
  • frequencies: the frequency descriptor (e.g., daily) per symbol.
  • currencies: currency code per symbol (USD for FED_DISCOUNT_RATE).

All calls use the GET method with api_key as a query parameter. The base URL is https://interestratesapi.com/api/v1/. For complete product details, visit Try Interest Rates API and Explore Interest Rates API features. To start building, Get started with Interest Rates API.

Time series: fetching multi-year FED_DISCOUNT_RATE data

For modeling or analytics, start with /timeseries. It returns a date-indexed series between start and end for specified symbols. FED_DISCOUNT_RATE is daily; you can request multiple years with one call. The API will include the frequency and currency metadata so you can validate your downstream assumptions.

cURL: /timeseries

curl -s "https://interestratesapi.com/api/v1/latest?api_key=YOUR_API_KEY&symbols=FED_DISCOUNT_RATE"

Sample JSON response (realistic fields)

{
    "success": true,
    "date": "2026-11-18",
    "base": "USD",
    "rates": {
        "FED_DISCOUNT_RATE": 4
    },
    "dates": {
        "FED_DISCOUNT_RATE": "2026-11-18"
    },
    "currencies": {
        "FED_DISCOUNT_RATE": "USD"
    },
    "base_filter_note": null
}

How to read it:

  • rates.FED_DISCOUNT_RATE is a mapping from ISO date to percentage level (per annum).
  • frequencies confirms daily data.
  • currencies shows USD for the symbol.

Python (requests) example: /timeseries

import requests

url = "https://interestratesapi.com/api/v1/timeseries"
params = {
"start": "2025-11-21",
"end": "2026-11-21",
"symbols": "FED_DISCOUNT_RATE",
"api_key": "YOUR_API_KEY"
}
resp = requests.get(url, params=params)
data = resp.json()

series = data["rates"]["FED_DISCOUNT_RATE"] # dict of date -> value (percentage p.a.)
freq = data["frequencies"]["FED_DISCOUNT_RATE"]
ccy = data["currencies"]["FED_DISCOUNT_RATE"]

print(f"Points: {len(series)}, frequency={freq}, currency={ccy}")
first_date = sorted(series.keys())[0]
print(first_date, series[first_date])

JavaScript (fetch) example: /timeseries

const url = "https://interestratesapi.com/api/v1/timeseries?start=2025-11-21&end=2026-11-21&symbols=FED_DISCOUNT_RATE&api_key=YOUR_API_KEY";
const res = await fetch(url);
const data = await res.json();
const series = data.rates["FED_DISCOUNT_RATE"]; // { "YYYY-MM-DD": number }

const dates = Object.keys(series).sort();
console.log("Observations:", dates.length);
console.log("First point:", dates[0], series[dates[0]]);

PHP example: /timeseries

<?php
$url = "https://interestratesapi.com/api/v1/timeseries?start=2025-11-21&end=2026-11-21&symbols=FED_DISCOUNT_RATE&api_key=YOUR_API_KEY";
$json = file_get_contents($url);
$data = json_decode($json, true);

$series = $data["rates"]["FED_DISCOUNT_RATE"];
$dates = array_keys($series);
sort($dates);

echo "Count: " . count($dates) . PHP_EOL;
echo "First row: " . $dates[0] . " = " . $series[$dates[0]] . PHP_EOL;
?>

Time series considerations

  • Missing dates: The series is business day-driven. Some calendar days are absent (weekends/holidays). Use the API’s dates as the canonical index.
  • Immutability: Historical levels are stable; if you cache, set a sensible TTL (e.g., daily refresh) and treat past records as immutable for reproducibility.
  • Effective dates: When rates change, the shift appears on the effective date returned by the API. Always align calculations (e.g., accruals) to these dates.

Point-in-time lookups with /historical

/historical answers “What was the discount rate on a given date?” Provide a YYYY-MM-DD. For daily symbols, if the date is a non-business day with no publication, expect the most recent business date with data within the range specified by the API; always validate your internal rule for rolling dates if needed.

cURL: /historical (single date)

Sample JSON

Note: The documentation states that for monthly symbols, the last day with data in that month is used. FED_DISCOUNT_RATE is daily, so you’ll typically get the level effective on that date if it exists (or the available date aligned by the API’s rules).

Latest reading and effective date

To show the current rate and effective date in dashboards, call /latest. Below is the official sample you can paste directly.

Official cURL: /latest

Official JSON response

Interpretation:

  • rates.FED_DISCOUNT_RATE = 4 means 4% per annum.
  • dates.FED_DISCOUNT_RATE shows the rate’s effective date, which you should display along with the value to avoid ambiguity.

Python (requests) example: /latest

import requests

resp = requests.get(
"https://interestratesapi.com/api/v1/latest",
params={"symbols": "FED_DISCOUNT_RATE", "api_key": "YOUR_API_KEY"}
)
data = resp.json()
rate = data["rates"]["FED_DISCOUNT_RATE"]
as_of = data["dates"]["FED_DISCOUNT_RATE"]
print(f"FED_DISCOUNT_RATE = {rate}% as of {as_of}")

JavaScript (fetch) example: /latest

const response = await fetch(
'https://interestratesapi.com/api/v1/latest?symbols=FED_DISCOUNT_RATE&api_key=YOUR_API_KEY'
);
const latest = await response.json();
console.log("Rate:", latest.rates["FED_DISCOUNT_RATE"], "As of:", latest.dates["FED_DISCOUNT_RATE"]);

PHP example: /latest

<?php
$url = 'https://interestratesapi.com/api/v1/latest?symbols=FED_DISCOUNT_RATE&api_key=YOUR_API_KEY';
$json = file_get_contents($url);
$data = json_decode($json, true);
$rate = $data['rates']['FED_DISCOUNT_RATE'];
$date = $data['dates']['FED_DISCOUNT_RATE'];
echo "FED_DISCOUNT_RATE = $rate% as of $date" . PHP_EOL;
?>

Fluctuation stats for change, high, and low

To summarize changes between two dates (start, end), use /fluctuation. It gives start_value, end_value, change, change_pct, high, and low for the range — ideal for performance summaries or alerting thresholds.

cURL: /fluctuation

Sample JSON

Python (requests) example: /fluctuation

import requests

resp = requests.get(
"https://interestratesapi.com/api/v1/fluctuation",
params={"start": "2025-11-21", "end": "2026-11-21", "symbols": "FED_DISCOUNT_RATE", "api_key": "YOUR_API_KEY"}
)
stats = resp.json()["rates"]["FED_DISCOUNT_RATE"]
print(stats["start_value"], stats["end_value"], stats["change"], stats["change_pct"], stats["high"], stats["low"])

JavaScript (fetch) example: /fluctuation

const url = "https://interestratesapi.com/api/v1/fluctuation?start=2025-11-21&end=2026-11-21&symbols=FED_DISCOUNT_RATE&api_key=YOUR_API_KEY";
const res = await fetch(url);
const data = await res.json();
const s = data.rates["FED_DISCOUNT_RATE"];
console.log(`Change ${s.change} (${s.change_pct}%), High ${s.high}, Low ${s.low}`);

PHP example: /fluctuation

<?php
$url = "https://interestratesapi.com/api/v1/fluctuation?start=2025-11-21&end=2026-11-21&symbols=FED_DISCOUNT_RATE&api_key=YOUR_API_KEY";
$json = file_get_contents($url);
$data = json_decode($json, true);
$s = $data["rates"]["FED_DISCOUNT_RATE"];
echo "Start: {$s['start_value']} End: {$s['end_value']} Change: {$s['change']} ({$s['change_pct']}%)" . PHP_EOL;
?>

OHLC for candlestick charts

/ohlc computes open, high, low, close on-the-fly from daily data. You can request monthly (default), weekly, or quarterly periods. Candlesticks are useful for visually summarizing ranges, especially across policy cycles.

cURL: /ohlc (monthly)

Sample JSON

data_points indicates the number of daily observations used to compute that candlestick, which helps you detect partial months or holiday-dense periods.

Python (requests) example: /ohlc

import requests

resp = requests.get(
"https://interestratesapi.com/api/v1/ohlc",
params={
"symbols": "FED_DISCOUNT_RATE",
"period": "monthly",
"start": "2025-11-21",
"end": "2026-11-21",
"api_key": "YOUR_API_KEY"
}
)
ohlc = resp.json()["rates"]["FED_DISCOUNT_RATE"]
print("First candle:", ohlc[0])

JavaScript (fetch) example: /ohlc

const url = "https://interestratesapi.com/api/v1/ohlc?symbols=FED_DISCOUNT_RATE&period=monthly&start=2025-11-21&end=2026-11-21&api_key=YOUR_API_KEY";
const res = await fetch(url);
const data = await res.json();
const candles = data.rates["FED_DISCOUNT_RATE"];
console.log(candles.map(c => [c.period, c.open, c.high, c.low, c.close]));

PHP example: /ohlc

<?php
$url = "https://interestratesapi.com/api/v1/ohlc?symbols=FED_DISCOUNT_RATE&period=monthly&start=2025-11-21&end=2026-11-21&api_key=YOUR_API_KEY";
$json = file_get_contents($url);
$data = json_decode($json, true);
$candles = $data["rates"]["FED_DISCOUNT_RATE"];
foreach ($candles as $c) {
echo "{$c['period']}: O={$c['open']} H={$c['high']} L={$c['low']} C={$c['close']} (n={$c['data_points']})" . PHP_EOL;
}
?>

Charting snippet (Plotly) for candlesticks

// Assumes you have fetched monthly OHLC into `candles` array of objects
const trace = {
x: candles.map(c => c.period),
open: candles.map(c => c.open),
high: candles.map(c => c.high),
low: candles.map(c => c.low),
close: candles.map(c => c.close),
type: 'candlestick',
increasing: { line: { color: '#2ca02c' } },
decreasing: { line: { color: '#d62728' } },
name: 'FED_DISCOUNT_RATE'
};
const layout = {
title: 'FED_DISCOUNT_RATE Monthly OHLC',
xaxis: { type: 'category' },
yaxis: { title: 'Percent (p.a.)' }
};
Plotly.newPlot('chart', [trace], layout);

Computing spreads and monthly payments from returned values

Since each rate is a percentage per annum, computing a spread is straightforward once you have two latest values. Example logic (no hardcoded numbers):

// Given r1 and r2 as percentages (e.g., 4 means 4% p.a.)
const spread = r1 - r2; // in percentage points

For a simple monthly payment approximation using simple interest (not amortized), you can use:

// principal = loan amount, r = annual percentage, m = term in months
const total_interest = principal * (r / 100) * (m / 12);
const total_payment = principal + total_interest;
const monthly_payment = total_payment / m;

If you need amortized monthly payments (common for mortgages), use the standard annuity formula without inserting numbers here:

// principal P, annual rate r (percent), monthly rate i = r/100/12, term m months
// monthly_payment = P * i / (1 - (1 + i)^(-m))

To compare simple loan interest costs quickly between FED_DISCOUNT_RATE and another benchmark, the API also exposes /convert, which computes total_interest and total_payment at the latest rates for a specified amount and term.

cURL: /convert (compare FED_DISCOUNT_RATE vs ECB_MRO)

Sample JSON

The totals in this response use a simple interest model. For amortized loans, compute payments client-side using the annuity formula above with the latest rate(s) you retrieve.

Build a Python data pipeline: fetch → DataFrame → CSV/Parquet

This end-to-end example downloads a multi-year FED_DISCOUNT_RATE series, constructs a tidy pandas DataFrame, forward-fills gaps onto a business-day index if desired, and exports both CSV and Parquet for downstream systems.

Full Python pipeline

import requests
import pandas as pd

API = "https://interestratesapi.com/api/v1/timeseries"
params = {
"start": "2020-01-01",
"end": "2026-12-31",
"symbols": "FED_DISCOUNT_RATE",
"api_key": "YOUR_API_KEY"
}
r = requests.get(API, params=params)
r.raise_for_status()
payload = r.json()

series = payload["rates"]["FED_DISCOUNT_RATE"] # dict: date string -> pct
df = pd.DataFrame(
{"rate_pct": pd.Series(series, dtype="float64")}
)
df.index = pd.to_datetime(df.index)
df.sort_index(inplace=True)

# Optional: reindex to US business days and forward-fill unchanged days
# (Choose your calendar conventions carefully for your use case.)
bidx = pd.bdate_range(df.index.min(), df.index.max(), freq="C") # weekday business days
df_bday = df.reindex(bidx).ffill()

# Save outputs
df.to_csv("fed_discount_rate_raw.csv", index_label="date")
df.to_parquet("fed_discount_rate_raw.parquet", index=True)

df_bday.to_csv("fed_discount_rate_business_days.csv", index_label="date")
df_bday.to_parquet("fed_discount_rate_business_days.parquet", index=True)

print("Rows (raw):", len(df), "Rows (business-day):", len(df_bday))

Notes:

  • df holds only observed days from the API. df_bday forward-fills onto business days. Choose the index that best matches your accrual assumptions.
  • The value rate_pct is in percent p.a.; divide by 100 for decimal rates when modeling interest math.

Discover and validate symbols

Use /symbols to filter for USD central bank rates, then confirm FED_DISCOUNT_RATE is available. This endpoint is also useful to audit frequency and descriptions programmatically.

cURL: /symbols (filter by category and base)

Sample JSON shape

The output will enumerate matching symbols and their metadata. You can cache this catalogue and refresh it periodically to keep autocomplete lists or validation logic current.

Operational details that save time

  • HTTP method: GET for all endpoints; authentication is api_key as a query parameter. Do not send auth headers.
  • Frequency: FED_DISCOUNT_RATE is daily. Not every calendar day appears in the series; expect gaps on weekends and holidays.
  • Effective dates: Use the dates map (where provided) to label or reconcile the as-of date per symbol.
  • Caching: For historical windows, cache indefinitely. For latest, a daily cache/refresh pattern typically suffices. Invalidate caches when you detect a date or rate change.
  • Errors: Handle structured errors (401/403/404/422/429). On 429, respect Retry-After and the X-RateLimit-* headers the API returns.
  • OHLC data_points: Use this to confirm if a candle aggregates a full set of observations for the period.

For more on integration patterns, see https://interestratesapi.com and the MCP reference.

FAQ

How is FED_DISCOUNT_RATE expressed in responses?
As a numeric percentage per annum. A value of 4 means 4% p.a. Convert to a decimal by dividing by 100 for calculations.

What date should I display as “as of” for the latest rate?
Use dates.FED_DISCOUNT_RATE from the /latest response. This is the effective date and should be shown alongside the value.

How do I handle weekends and holidays in time series?
The API returns business-day observations. If you require a continuous business-day index, reindex and forward-fill carefully to avoid implying rate changes where none exist.

Can I build candlesticks from historical data without using /ohlc?
Yes. You can compute open/high/low/close from /timeseries by grouping by month or week. /ohlc simply performs that computation server-side and returns data_points for validation.

What’s the best way to compute loan payments from FED_DISCOUNT_RATE?
Use the returned percentage as the annual nominal rate. For simple interest, multiply principal by (rate/100) by term_years. For amortized schedules, use the annuity formula with monthly rate = (rate/100)/12. Validate which convention matches your product.

If you’re ready to integrate FED_DISCOUNT_RATE into production, grab an API key and start building with GET requests today. Register. Also see the Try Interest Rates API, Explore Interest Rates API features, and Get started with Interest Rates API pages for quick starts and examples.

Ready to get started?

Get your API key and start validating bank data in minutes.

Get API Key