How to Get the Fed Discount Rate (FED_DISCOUNT_RATE) Rate

How to Get the Fed Discount Rate (FED_DISCOUNT_RATE) Rate

You need to programmatically fetch the Federal Reserve Primary Credit Discount Rate for your application and turn it into actionable metrics—latest value, historical movements, OHLC aggregates, and loan cost comparisons—without building a data pipeline from scratch. By the end of this tutorial, you’ll query FED_DISCOUNT_RATE over a REST API, interpret effective dates and units, compute spreads and payments from the returned values, and integrate the seven core endpoints into dashboards, pricing engines, and risk tools.

Understanding FED_DISCOUNT_RATE: what it is and why it matters

FED_DISCOUNT_RATE is the Federal Reserve’s primary credit discount rate—what eligible depository institutions pay to borrow overnight from the Federal Reserve’s discount window. It is a central bank policy rate denominated in USD. Because it is a penalty-rate-like instrument relative to interbank funding, its level and changes reflect monetary policy stance and serve as a ceiling in corridor systems alongside the Interest on Reserve Balances (IORB) and the federal funds rate.

Illustration: How to Get the Fed Discount Rate (FED_DISCOUNT_RATE) Rate

For developers and analysts, tracking FED_DISCOUNT_RATE helps to:

  • Flag policy regime shifts for risk and ALM models.
  • Parameterize loan pricing logic that pegs or caps against policy benchmarks.
  • Power macro research dashboards and time series visualizations.
  • Backtest strategy responses to policy tightening/loosening cycles.

How the Interest Rates API delivers FED_DISCOUNT_RATE

All endpoints are HTTP GET, base URL https://interestratesapi.com, and authentication is via the api_key query parameter. The symbol for this article is FED_DISCOUNT_RATE. Frequency is daily, currency is USD, and values are expressed as percentage rates (numeric). For example, a response with "FED_DISCOUNT_RATE": 4 represents 4 percent annualized.

Key response patterns to know:

  • rates: a map from symbol to numeric value (percentage).
  • dates: a map of symbol to effective date (Y-m-d) when provided by the endpoint.
  • currencies: a map of symbol to ISO currency code.
  • frequencies: symbol-to-frequency map for time series endpoints.
  • OHLC fields: open, high, low, close plus data_points for aggregate periods.
  • Fluctuation fields: start_value, end_value, change, change_pct, high, low.

When you see a dates map, treat it as the effective date for the rate’s latest observation. On weekends and U.S. federal holidays, daily policy rates typically remain unchanged; the API continues to return the last effective date until a new observation is published. You should cache responses and plan around business-day updates.

Get an API key and start building: Register or consult the MCP. You can also explore product info at interestratesapi.com.

Get the latest FED_DISCOUNT_RATE

Use the latest endpoint to retrieve the most recent available value and its effective date. The following cURL and JSON are official samples—copy them as-is and replace YOUR_API_KEY.

curl -s "https://interestratesapi.com/api/v1/latest?api_key=YOUR_API_KEY&symbols=FED_DISCOUNT_RATE"
{
    "success": true,
    "date": "2026-10-20",
    "base": "USD",
    "rates": {
        "FED_DISCOUNT_RATE": 4
    },
    "dates": {
        "FED_DISCOUNT_RATE": "2026-10-20"
    },
    "currencies": {
        "FED_DISCOUNT_RATE": "USD"
    },
    "base_filter_note": null
}

How to read this:

  • rates.FED_DISCOUNT_RATE is the latest rate in percent (here, 4 means 4.00%).
  • dates.FED_DISCOUNT_RATE is the effective date (Y-m-d) for that observation.
  • base and currencies map confirm USD denomination for the symbol.

Latest in Python

import requests

url = "https://interestratesapi.com/api/v1/latest"
params = {
"symbols": "FED_DISCOUNT_RATE",
"api_key": "YOUR_API_KEY"
}
resp = requests.get(url, params=params)
data = resp.json()

rate = data["rates"]["FED_DISCOUNT_RATE"] # percentage
effective_date = data["dates"]["FED_DISCOUNT_RATE"] # Y-m-d
currency = data["currencies"]["FED_DISCOUNT_RATE"] # "USD"

print(rate, effective_date, currency)

Latest in JavaScript (fetch)

const response = await fetch(
"https://interestratesapi.com/api/v1/latest?symbols=FED_DISCOUNT_RATE&api_key=YOUR_API_KEY"
);
const data = await response.json();

const rate = data.rates.FED_DISCOUNT_RATE; // percentage
const effectiveDate = data.dates.FED_DISCOUNT_RATE; // Y-m-d
const currency = data.currencies.FED_DISCOUNT_RATE; // "USD"

console.log(rate, effectiveDate, currency);

Latest in PHP

<?php
$url = "https://interestratesapi.com/api/v1/latest?symbols=FED_DISCOUNT_RATE&api_key=YOUR_API_KEY";
$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$json = curl_exec($ch);
curl_close($ch);
$data = json_decode($json, true);

$rate = $data["rates"]["FED_DISCOUNT_RATE"];
$effectiveDate = $data["dates"]["FED_DISCOUNT_RATE"];
$currency = $data["currencies"]["FED_DISCOUNT_RATE"];

echo $rate . " " . $effectiveDate . " " . $currency;
?>

Discover the symbol via the symbols catalogue

To confirm availability, category, currency, and frequency, query /symbols. Filter by central_bank and USD to see FED_DISCOUNT_RATE along with other USD policy rates.

Note: The response above is illustrative and shows the shape and fields. The endpoint returns a list of symbols matching your filters. You’ll find FED_DISCOUNT_RATE in the central_bank category with currency_code USD and frequency daily.

Symbols in Python

import requests

resp = requests.get(
"https://interestratesapi.com/api/v1/symbols",
params={"category": "central_bank", "base": "USD", "api_key": "YOUR_KEY"},
)
catalog = resp.json()

symbols = [s["symbol"] for s in catalog.get("symbols", [])]
print(symbols)

Symbols in JavaScript

const res = await fetch(
"https://interestratesapi.com/api/v1/symbols?category=central_bank&base=USD&api_key=YOUR_KEY"
);
const catalog = await res.json();
const symbols = (catalog.symbols || []).map(s => s.symbol);
console.log(symbols);

Symbols in PHP

<?php
$url = "https://interestratesapi.com/api/v1/symbols?category=central_bank&base=USD&api_key=YOUR_KEY";
$body = file_get_contents($url);
$catalog = json_decode($body, true);
$symbols = array_map(fn($s) => $s["symbol"], $catalog["symbols"] ?? []);
print_r($symbols);
?>

Look up FED_DISCOUNT_RATE on a specific date

Use the historical endpoint to fetch the value on a given date. For daily symbols, that date is the most recent business day on/after which the value applies, using the exact observation for that calendar date if available.

Here, rates.FED_DISCOUNT_RATE is the rate (percent) associated with that date. The response is scoped to the provided date, and returns USD currency metadata.

Historical in Python

import requests
params = {"date": "2025-06-15", "symbols": "FED_DISCOUNT_RATE", "api_key": "YOUR_KEY"}
r = requests.get("https://interestratesapi.com/api/v1/historical", params=params)
data = r.json()
value = data["rates"]["FED_DISCOUNT_RATE"]
print(value)

Historical in JavaScript

const url = "https://interestratesapi.com/api/v1/historical?date=2025-06-15&symbols=FED_DISCOUNT_RATE&api_key=YOUR_KEY";
const resp = await fetch(url);
const data = await resp.json();
console.log(data.rates.FED_DISCOUNT_RATE);

Historical in PHP

<?php
$url = "https://interestratesapi.com/api/v1/historical?date=2025-06-15&symbols=FED_DISCOUNT_RATE&api_key=YOUR_KEY";
$json = file_get_contents($url);
$data = json_decode($json, true);
echo $data["rates"]["FED_DISCOUNT_RATE"];
?>

Build a time series for FED_DISCOUNT_RATE

To chart or backtest, fetch a date range with /timeseries. The API returns a map of date to value for the symbol, plus frequency and currency metadata you can depend on when storing or resampling.

Interpretation:

  • rates.FED_DISCOUNT_RATE is a date-indexed series (Y-m-d keys, percent values).
  • frequencies confirms the series cadence is daily; handle gaps around weekends/holidays.
  • Use start_date and end_date to validate completeness of the range.

Timeseries in Python

import requests
params = {
"start": "2025-10-23",
"end": "2026-10-23",
"symbols": "FED_DISCOUNT_RATE",
"api_key": "YOUR_KEY",
}
ts = requests.get("https://interestratesapi.com/api/v1/timeseries", params=params).json()
series = ts["rates"]["FED_DISCOUNT_RATE"] # dict of {date: value}
print(list(series.items())[:5])

Timeseries in JavaScript

const res = await fetch(
"https://interestratesapi.com/api/v1/timeseries?start=2025-10-23&end=2026-10-23&symbols=FED_DISCOUNT_RATE&api_key=YOUR_KEY"
);
const ts = await res.json();
const series = ts.rates.FED_DISCOUNT_RATE;
console.log(Object.entries(series).slice(0, 5));

Timeseries in PHP

<?php
$url = "https://interestratesapi.com/api/v1/timeseries?start=2025-10-23&end=2026-10-23&symbols=FED_DISCOUNT_RATE&api_key=YOUR_KEY";
$json = file_get_contents($url);
$ts = json_decode($json, true);
$series = $ts["rates"]["FED_DISCOUNT_RATE"];
print_r(array_slice($series, 0, 5, true));
?>

Quantify changes with fluctuation stats

To summarize movement over a period—start, end, net change, percentage change, and extremes—use /fluctuation. This is ideal for risk summaries and reporting.

Use fields as follows:

  • start_value and end_value: level at the first and last dates in range.
  • change and change_pct: absolute and percent change.
  • high and low: range extremes within [start, end].

Fluctuation in Python

import requests
params = {"start": "2025-10-23", "end": "2026-10-23", "symbols": "FED_DISCOUNT_RATE", "api_key": "YOUR_KEY"}
fl = requests.get("https://interestratesapi.com/api/v1/fluctuation", params=params).json()
stats = fl["rates"]["FED_DISCOUNT_RATE"]
print(stats)

Fluctuation in JavaScript

const url = "https://interestratesapi.com/api/v1/fluctuation?start=2025-10-23&end=2026-10-23&symbols=FED_DISCOUNT_RATE&api_key=YOUR_KEY";
const data = await fetch(url).then(r => r.json());
console.log(data.rates.FED_DISCOUNT_RATE);

Fluctuation in PHP

<?php
$url = "https://interestratesapi.com/api/v1/fluctuation?start=2025-10-23&end=2026-10-23&symbols=FED_DISCOUNT_RATE&api_key=YOUR_KEY";
$json = file_get_contents($url);
$data = json_decode($json, true);
print_r($data["rates"]["FED_DISCOUNT_RATE"]);
?>

Aggregate into OHLC periods

For charting and reporting, /ohlc computes open, high, low, close for weekly, monthly, or quarterly periods on the fly from daily observations. This is useful when you need candle charts or coarse-grained summaries without manual resampling.

How to use:

  • period: the aggregation bucket (monthly here).
  • Each item shows period label (YYYY-MM), OHLC values (percent), and data_points (count of daily observations contributing to the bucket).

OHLC in Python

import requests
params = {
"symbols": "FED_DISCOUNT_RATE",
"period": "monthly",
"start": "2025-10-23",
"end": "2026-10-23",
"api_key": "YOUR_KEY",
}
ohlc = requests.get("https://interestratesapi.com/api/v1/ohlc", params=params).json()
print(ohlc["rates"]["FED_DISCOUNT_RATE"][:1])

OHLC in JavaScript

const ohlcUrl = "https://interestratesapi.com/api/v1/ohlc?symbols=FED_DISCOUNT_RATE&period=monthly&start=2025-10-23&end=2026-10-23&api_key=YOUR_KEY";
const ohlc = await fetch(ohlcUrl).then(r => r.json());
console.log(ohlc.rates.FED_DISCOUNT_RATE[0]);

OHLC in PHP

<?php
$url = "https://interestratesapi.com/api/v1/ohlc?symbols=FED_DISCOUNT_RATE&period=monthly&start=2025-10-23&end=2026-10-23&api_key=YOUR_KEY";
$json = file_get_contents($url);
$ohlc = json_decode($json, true);
print_r($ohlc["rates"]["FED_DISCOUNT_RATE"][0]);
?>

Compare interest costs with convert

For quick loan cost comparisons across benchmarks, /convert estimates total interest and total payment for a simple loan at the latest rate of each symbol. While your production loan engine may use compounding or amortization rules, this endpoint provides a simple, standardized comparison to highlight spread-driven differences.

Interpretation:

  • from and to blocks report each symbol’s latest rate, effective date, and simple interest totals for the specified amount and term_months.
  • difference.rate_spread is the latest-rate delta (in percentage points). Use this for quick pricing deltas and scenario comparisons.

Convert in Python

import requests
params = {
"from": "FED_DISCOUNT_RATE",
"to": "ECB_MRO",
"amount": 100000,
"term_months": 12,
"api_key": "YOUR_KEY",
}
comp = requests.get("https://interestratesapi.com/api/v1/convert", params=params).json()
print(comp["difference"]["rate_spread"], comp["difference"]["interest_saved"])

Convert in JavaScript

const conv = await fetch(
"https://interestratesapi.com/api/v1/convert?from=FED_DISCOUNT_RATE&to=ECB_MRO&amount=100000&term_months=12&api_key=YOUR_KEY"
).then(r => r.json());
console.log(conv.difference.rate_spread, conv.difference.interest_saved);

Convert in PHP

<?php
$url = "https://interestratesapi.com/api/v1/convert?from=FED_DISCOUNT_RATE&to=ECB_MRO&amount=100000&term_months=12&api_key=YOUR_KEY";
$json = file_get_contents($url);
$conv = json_decode($json, true);
echo $conv["difference"]["rate_spread"] . " " . $conv["difference"]["interest_saved"];
?>

Compute spreads and payments from returned values

Beyond /convert, you often need explicit calculations. Because rates are returned as annual percentages, convert to decimals for math (e.g., r = value / 100).

  • Spread between two rates: spread_pp = rateA - rateB (in percentage points). Spread_decimal = (rateA - rateB) / 100.
  • Monthly payment on an amortizing loan: given principal P, annual rate r (percent), and term n months, monthly rate i = (r / 100) / 12. Then payment M = P * i / (1 - (1 + i)^(-n)).
  • Simple monthly interest (non-amortizing): interest_per_month = P * (r / 100) / 12.

Use the effective dates returned by the API when validating your pricing date or when caching results. If your pricing date differs from the effective date, decide whether to re-fetch on the next business day.

Production details: frequency, business days, caching, and errors

Publication frequency: FED_DISCOUNT_RATE is reported daily. However, updates align with Federal Reserve business days and policy decisions; on weekends and holidays, the latest effective date typically stays constant. Your application should tolerate unchanged values across non-business days.

Caching: Given stable daily updates, a cache TTL aligned to business day boundaries is reasonable (for example, refresh after market open in the U.S.). For time series and OHLC, cache by request signature (start, end, symbols, period).

Rate limits and retries: The API returns standard rate limit headers. If you receive 429, check X-RateLimit-Remaining and X-RateLimit-Reset and backoff accordingly.

  • X-RateLimit-Limit: your bucket limit.
  • X-RateLimit-Remaining: requests left in the window.
  • X-RateLimit-Reset: Unix epoch seconds to reset.

Error handling uses a consistent shape:

  • 401: Missing or invalid api_key.
  • 403: Account without active plan.
  • 404: No symbols matched or no data for requested date/range (may include details with available ranges).
  • 422: Validation error (date format, invalid symbol).
  • 429: Quota exhausted (use Retry-After header and rate limit headers).

All endpoints are GET and authenticated via api_key in the query string. Avoid sending keys in headers; they are ignored for auth.

Real-world integration patterns

  • Interest rate dashboards: Use /latest for headline tiles, /timeseries for charts, and /ohlc for monthly candles. Align tooltips with dates.FED_DISCOUNT_RATE.
  • Lending and mortgage platforms: Parameterize product pricing or caps with FED_DISCOUNT_RATE; calculate amortizing payments from the latest value and show spreads to other policy or interbank rates.
  • Treasury and ALM: Monitor fluctuation stats weekly or monthly; alert when change_pct breaches thresholds.
  • Macro research and quant backtests: Pull multi-year ranges from /timeseries and compute regime features (levels, first/second differences) and policy-window OHLC.

Explore more at interestratesapi.com, or jump into the MCP for model and endpoint documentation.

FAQ

How is FED_DISCOUNT_RATE expressed in responses?
As a numeric percentage (e.g., 4 means 4.00% annualized). Convert to decimal by dividing by 100 for calculations.

What date should I display as the “as of” time?
Use the dates map for the symbol (e.g., dates.FED_DISCOUNT_RATE). This is the effective date of the observation.

How often does FED_DISCOUNT_RATE update?
It is a daily-frequency policy rate. Values typically change on Federal Reserve business days and policy decision dates; weekends and holidays usually show the last effective observation.

Can I get monthly aggregates without storing daily data?
Yes. Use /ohlc with period=monthly. The API computes open, high, low, close from daily observations and returns data_points for transparency.

How do I compute a loan payment from the latest rate?
Convert the rate to a monthly decimal i = (rate / 100) / 12, then use the standard amortization formula M = P * i / (1 - (1 + i)^(-n)), where P is principal and n is term in months.

Build your integration now: fetch the latest FED_DISCOUNT_RATE, wire up time series and OHLC, and ship features. Register to get an API key, or browse the MCP to plan your endpoints.

Keywords
federal reserve api fetch discount rate programmatic data access financial metrics API historical rate analysis

Ready to get started?

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

Get API Key