Your app needs the Federal Reserve’s Primary Credit Discount Rate in real time, but stitching together data pipelines, publication calendars, and time-series math slows you down. By the end of this guide, you’ll query the FED_DISCOUNT_RATE symbol from the Interest Rates API, interpret effective dates, work with historical and OHLC series, compute spreads and monthly payments from the returned values, and productionize your integration with caching and error handling.
What the Federal Reserve Primary Credit Discount Rate (FED_DISCOUNT_RATE) Represents
FED_DISCOUNT_RATE is the Federal Reserve’s Primary Credit Discount Rate expressed as an annualized percentage in USD. It is the rate at which eligible depository institutions can borrow short-term funds directly from the Federal Reserve’s discount window under primary credit. The rate is set administratively by the Federal Reserve Banks, with changes announced via the Federal Reserve System. In practice, it’s a key policy tool: while the federal funds rate targets interbank lending, the discount rate sets a ceiling and can influence liquidity conditions and funding backstops.
Why it matters to developers and analysts:
- As a central bank policy rate, it anchors stress and liquidity modeling, bank funding assumptions, and monetary policy dashboards.
- It provides a reference for benchmarking lines of credit, warehouse funding, and stress test scenarios.
- It’s often used alongside FED_FUNDS, FED_IORB, and Treasury yields in macro research and risk analytics.
The Interest Rates API exposes this rate under the symbol FED_DISCOUNT_RATE, updated on its publication schedule, and normalized as a daily time series in USD.
How the Interest Rates API represents FED_DISCOUNT_RATE
All endpoints are GET requests under the base URL https://interestratesapi.com/api/v1/ and authenticate with an api_key parameter. The API returns JSON with documented fields only. Rates are returned as percentages (e.g., 4 means 4 percent annualized). Dates are ISO-8601 (Y-m-d, UTC). For daily series like FED_DISCOUNT_RATE, the “date” and symbol-specific “dates” indicate the effective business date of the observation.
Key shapes you will see across endpoints:
- rates: a map from symbol to numeric rate value.
- dates: a per-symbol map of the effective date for the latest endpoint.
- currencies: a per-symbol map (USD for FED_DISCOUNT_RATE).
- frequencies: a per-symbol map describing publication frequency (daily for FED_DISCOUNT_RATE).
- fluctuation stats: start_value, end_value, change, change_pct, high, low.
- OHLC: arrays of objects with open, high, low, close and data_points counts.
Explore the platform at interestratesapi.com. To go deeper into models and capabilities, see the MCP. If you’re ready to test with a key, Register.
Discovering the symbol catalogue
Use the symbols endpoint to verify availability and metadata. You can filter by category central_bank and base USD to focus on US policy rates, including FED_DISCOUNT_RATE.
Endpoint: GET /api/v1/symbols
cURL:
curl -s "https://interestratesapi.com/api/v1/latest?api_key=YOUR_API_KEY&symbols=FED_DISCOUNT_RATE"
JSON response example (truncated to illustrate the schema):
{
"success": true,
"date": "2026-11-03",
"base": "USD",
"rates": {
"FED_DISCOUNT_RATE": 4
},
"dates": {
"FED_DISCOUNT_RATE": "2026-11-03"
},
"currencies": {
"FED_DISCOUNT_RATE": "USD"
},
"base_filter_note": null
}
Python (requests):
import requests
resp = requests.get(
"https://interestratesapi.com/api/v1/symbols",
params=dict(category="central_bank", base="USD", api_key="YOUR_API_KEY"),
timeout=30
)
catalog = resp.json()
symbols = [s["symbol"] for s in catalog.get("symbols", [])]
print("Available:", symbols)
JavaScript (fetch):
const url = "https://interestratesapi.com/api/v1/symbols?category=central_bank&base=USD&api_key=YOUR_API_KEY";
const res = await fetch(url);
const json = await res.json();
const symbols = (json.symbols || []).map(s => s.symbol);
console.log(symbols.includes("FED_DISCOUNT_RATE"));
PHP:
<?php
$url = "https://interestratesapi.com/api/v1/symbols?category=central_bank&base=USD&api_key=YOUR_API_KEY";
$json = file_get_contents($url);
$data = json_decode($json, true);
$symbols = array_map(fn($s) => $s["symbol"], $data["symbols"] ?? []);
print_r($symbols);
?>
Practical note: frequency for FED_DISCOUNT_RATE is daily, meaning the series has business-day granularity but may hold the same value for multiple days between official changes.
Latest reading for FED_DISCOUNT_RATE
Use the latest endpoint to fetch the current effective discount rate. The official sample below must be copied exactly for correctness verification.
Endpoint: GET /api/v1/latest
cURL (OFFICIAL SAMPLE):
JSON (OFFICIAL SAMPLE):
How to read this:
- rates.FED_DISCOUNT_RATE is the discount rate in percent (annualized). Interpret 4 as 4 percent per annum.
- date is the response date; dates.FED_DISCOUNT_RATE is the effective date of the observation for this symbol.
- currencies.FED_DISCOUNT_RATE confirms USD denomination.
Python (requests):
import requests
r = requests.get(
"https://interestratesapi.com/api/v1/latest",
params=dict(api_key="YOUR_API_KEY", symbols="FED_DISCOUNT_RATE"),
timeout=30
)
data = r.json()
rate = data["rates"]["FED_DISCOUNT_RATE"]
effective_date = data["dates"]["FED_DISCOUNT_RATE"]
print(f"Discount Rate: {rate}% (effective {effective_date})")
JavaScript (fetch):
const resp = await fetch(
"https://interestratesapi.com/api/v1/latest?symbols=FED_DISCOUNT_RATE&api_key=YOUR_API_KEY"
);
const latest = await resp.json();
const rate = latest.rates.FED_DISCOUNT_RATE;
const eff = latest.dates.FED_DISCOUNT_RATE;
console.log(`FED_DISCOUNT_RATE ${rate}% effective ${eff}`);
PHP:
<?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"] ?? null;
$eff = $data["dates"]["FED_DISCOUNT_RATE"] ?? null;
echo "FED_DISCOUNT_RATE: {$rate}% effective {$eff}\n";
?>
Historical point-in-time value
For backtesting, audit trails, or reproducing a model run, query the rate on a specific date. If you pass a date where the rate did not change, you’ll receive the value effective on that date according to the daily series.
Endpoint: GET /api/v1/historical
cURL:
JSON response example:
Python (requests):
import requests
params = dict(date="2025-06-15", symbols="FED_DISCOUNT_RATE", api_key="YOUR_API_KEY")
r = requests.get("https://interestratesapi.com/api/v1/historical", params=params, timeout=30)
hist = r.json()
value = hist["rates"]["FED_DISCOUNT_RATE"]
print("On 2025-06-15:", value, "%")
JavaScript (fetch):
const h = await fetch(
"https://interestratesapi.com/api/v1/historical?date=2025-06-15&symbols=FED_DISCOUNT_RATE&api_key=YOUR_API_KEY"
).then(r => r.json());
console.log(`Historical value: ${h.rates.FED_DISCOUNT_RATE}% on ${h.date}`);
PHP:
<?php
$params = http_build_query([
"date" => "2025-06-15",
"symbols" => "FED_DISCOUNT_RATE",
"api_key" => "YOUR_API_KEY"
]);
$url = "https://interestratesapi.com/api/v1/historical?$params";
$data = json_decode(file_get_contents($url), true);
echo $data["rates"]["FED_DISCOUNT_RATE"] . "% on " . $data["date"] . "\n";
?>
Time series for charts, models, and rolling computations
Use the timeseries endpoint to pull a continuous daily series between two dates for FED_DISCOUNT_RATE. This is useful for charting policy regimes, calculating durations between changes, and computing rolling statistics.
Endpoint: GET /api/v1/timeseries
cURL:
JSON response example:
Python (requests):
import requests
params = dict(
start="2025-11-06",
end="2026-11-06",
symbols="FED_DISCOUNT_RATE",
api_key="YOUR_API_KEY"
)
r = requests.get("https://interestratesapi.com/api/v1/timeseries", params=params, timeout=60)
series = r.json()
ts = series["rates"]["FED_DISCOUNT_RATE"]
# Example: count distinct change points
prev = None
changes = 0
for d in sorted(ts.keys()):
if ts[d] != prev and prev is not None:
changes += 1
prev = ts[d]
print("Distinct changes:", changes)
JavaScript (fetch):
const url = "https://interestratesapi.com/api/v1/timeseries?start=2025-11-06&end=2026-11-06&symbols=FED_DISCOUNT_RATE&api_key=YOUR_API_KEY";
const res = await fetch(url);
const out = await res.json();
const points = Object.entries(out.rates.FED_DISCOUNT_RATE)
.map(([date, val]) => ({ t: date, y: val }));
console.log(points.length, "data points");
PHP:
<?php
$q = http_build_query([
"start" => "2025-11-06",
"end" => "2026-11-06",
"symbols" => "FED_DISCOUNT_RATE",
"api_key" => "YOUR_API_KEY"
]);
$data = json_decode(file_get_contents("https://interestratesapi.com/api/v1/timeseries?$q"), true);
$ts = $data["rates"]["FED_DISCOUNT_RATE"] ?? [];
echo "First date: " . array_key_first($ts) . ", last date: " . array_key_last($ts) . PHP_EOL;
?>
Fluctuation statistics across a period
If you need summary stats for the rate between two dates—start value, end value, high/low, and percent change—use the fluctuation endpoint.
Endpoint: GET /api/v1/fluctuation
cURL:
JSON response example:
Python (requests):
import requests
params = dict(start="2025-11-06", end="2026-11-06", symbols="FED_DISCOUNT_RATE", api_key="YOUR_API_KEY")
r = requests.get("https://interestratesapi.com/api/v1/fluctuation", params=params, timeout=30)
stat = r.json()["rates"]["FED_DISCOUNT_RATE"]
print(f"Δ {stat['change']}pp, {stat['change_pct']}% | High {stat['high']} Low {stat['low']}")
JavaScript (fetch):
const f = await fetch(
"https://interestratesapi.com/api/v1/fluctuation?start=2025-11-06&end=2026-11-06&symbols=FED_DISCOUNT_RATE&api_key=YOUR_API_KEY"
).then(r => r.json());
const s = f.rates.FED_DISCOUNT_RATE;
console.log(`Start ${s.start_value} End ${s.end_value} Change ${s.change_pct}%`);
PHP:
<?php
$q = http_build_query([
"start" => "2025-11-06",
"end" => "2026-11-06",
"symbols" => "FED_DISCOUNT_RATE",
"api_key" => "YOUR_API_KEY"
]);
$data = json_decode(file_get_contents("https://interestratesapi.com/api/v1/fluctuation?$q"), true);
$s = $data["rates"]["FED_DISCOUNT_RATE"] ?? [];
echo "Change: {$s['change']}pp ({$s['change_pct']}%)\n";
?>
Notes:
- change is the end_value minus start_value, in percentage points.
- change_pct is the relative change versus start_value (null if start_value is 0).
- high/low are extremes observed during the interval.
OHLC candlestick data from daily observations
For charting, you might prefer monthly or weekly OHLC bars. The API computes OHLC on-the-fly from the daily series for FED_DISCOUNT_RATE.
Endpoint: GET /api/v1/ohlc
cURL:
JSON response example:
Python (requests):
import requests
params = dict(symbols="FED_DISCOUNT_RATE", period="monthly", start="2025-11-06", end="2026-11-06", api_key="YOUR_API_KEY")
r = requests.get("https://interestratesapi.com/api/v1/ohlc", params=params, timeout=30)
ohlc = r.json()["rates"]["FED_DISCOUNT_RATE"]
for bar in ohlc:
print(bar["period"], bar["open"], bar["high"], bar["low"], bar["close"], bar["data_points"])
JavaScript (fetch):
const o = await fetch(
"https://interestratesapi.com/api/v1/ohlc?symbols=FED_DISCOUNT_RATE&period=monthly&start=2025-11-06&end=2026-11-06&api_key=YOUR_API_KEY"
).then(r => r.json());
(o.rates.FED_DISCOUNT_RATE || []).forEach(bar => {
console.log(`${bar.period} O:${bar.open} H:${bar.high} L:${bar.low} C:${bar.close} n=${bar.data_points}`);
});
PHP:
<?php
$q = http_build_query([
"symbols" => "FED_DISCOUNT_RATE",
"period" => "monthly",
"start" => "2025-11-06",
"end" => "2026-11-06",
"api_key" => "YOUR_API_KEY"
]);
$data = json_decode(file_get_contents("https://interestratesapi.com/api/v1/ohlc?$q"), true);
foreach (($data["rates"]["FED_DISCOUNT_RATE"] ?? []) as $bar) {
echo "{$bar['period']} O:{$bar['open']} H:{$bar['high']} L:{$bar['low']} C:{$bar['close']} n={$bar['data_points']}\n";
}
?>
OHLC specifics:
- data_points counts business-day observations used to compute the bar.
- These OHLC bars reflect the daily effective values, not intraday moves.
Comparing loan interest costs and computing spreads
To compare costs between two benchmark rates’ latest values (e.g., FED_DISCOUNT_RATE vs. another policy rate), use the convert endpoint. It estimates total interest over a simple loan using the latest rates.
Endpoint: GET /api/v1/convert
cURL:
JSON response example:
Python (requests):
import requests
params = dict(from="FED_DISCOUNT_RATE", to="ECB_MRO", amount=100000, term_months=12, api_key="YOUR_API_KEY")
r = requests.get("https://interestratesapi.com/api/v1/convert", params=params, timeout=30)
cmp = r.json()
print("Spread (pp):", cmp["difference"]["rate_spread"])
print("Interest saved:", cmp["difference"]["interest_saved"])
JavaScript (fetch):
const c = await fetch(
"https://interestratesapi.com/api/v1/convert?from=FED_DISCOUNT_RATE&to=ECB_MRO&amount=100000&term_months=12&api_key=YOUR_API_KEY"
).then(r => r.json());
console.log(`Rate spread: ${c.difference.rate_spread}pp, interest saved: ${c.difference.interest_saved}`);
PHP:
<?php
$q = http_build_query([
"from" => "FED_DISCOUNT_RATE",
"to" => "ECB_MRO",
"amount" => 100000,
"term_months" => 12,
"api_key" => "YOUR_API_KEY"
]);
$data = json_decode(file_get_contents("https://interestratesapi.com/api/v1/convert?$q"), true);
echo "Spread: {$data['difference']['rate_spread']}pp\n";
?>
How to compute spreads or monthly payments yourself from latest values:
- Spread (in percentage points) = rate_A − rate_B, where both are in percent (e.g., 4.25 − 4.00 = 0.25pp).
- Simple monthly interest for a notional N using an annual percent rate r% over m months can be approximated as N × (r/100) × (m/12). For amortized loans, use the standard payment formula with monthly_rate = r/100/12, payment = N × monthly_rate / (1 − (1 + monthly_rate)^(−m)). Use the API’s latest rate as r.
Note: Do not hardcode example values in production; always fetch the current rate from the API before computing spreads or payments.
Operational details: publication cadence, business days, effective dates, and caching
Publication frequency: FED_DISCOUNT_RATE is a daily series in the API. The value updates on business days when changes occur; otherwise, it may be unchanged across days until the next administrative adjustment.
Business days and holidays: Daily series reflect business-day calendars. If you request a historical date that is a weekend or holiday, the series returns the value effective on that date according to its daily indexing (which may match the most recent business day if no change occurred).
Effective dates: The dates map in the latest endpoint shows the effective date per symbol. In time series, each date key represents the effective daily observation for that day.
Caching and ETL guidance:
- Cache the latest endpoint result locally with a short TTL (e.g., 1–4 hours) to reduce latency and rate-limit usage for dashboards.
- Use the timeseries endpoint for bulk backfill and keep an internal store. Then serve most reads from your cache and refresh incrementally.
- Use ETag/If-Modified-Since strategies at your edge where applicable; also log X-RateLimit headers to tune your polling interval.
Error handling: The API uses clear error codes and a consistent error shape. Watch for:
- 401 for missing or invalid api_key, 403 for inactive account.
- 404 if symbols don’t match or date/range has no data (details may specify available ranges).
- 422 for validation errors (e.g., malformed date or invalid symbol).
- 429 when your quota is exhausted; use Retry-After and X-RateLimit-* headers to backoff.
See interestratesapi.com for more platform details, and review the MCP for integration guidance.
Production patterns for FED_DISCOUNT_RATE users
Common use cases for treasury and fintech teams include:
- Policy dashboards: display latest FED_DISCOUNT_RATE, change since last month, and OHLC bar charts.
- Risk and stress testing: pull timeseries to simulate funding cost shocks or policy regime transitions.
- Loan pricing tools: compute adjustable-rate margins over FED_DISCOUNT_RATE, and compare alternatives with the convert endpoint.
- Macro research: align FED_DISCOUNT_RATE with other policy symbols or interbank benchmarks for cross-market analysis.
Implementation checklist:
- Start by verifying the symbol via /symbols.
- Fetch /latest for UI and daily cron jobs; cache and log the dates map for auditing.
- Backfill historical context with /timeseries and pre-compute rolling metrics.
- Use /fluctuation for quick performance summaries and reporting.
- For charting, use /ohlc to simplify bar construction.
- To show cross-rate comparisons, call /convert and surface spreads and total interest diffs.
Complete endpoint reference for FED_DISCOUNT_RATE (with ready-to-copy code)
1) Catalogue: GET /api/v1/symbols
cURL:
Python, JavaScript, PHP samples are provided above in the symbols section.
2) Latest: GET /api/v1/latest
cURL (OFFICIAL SAMPLE):
JSON (OFFICIAL SAMPLE) shown above. Python/JS/PHP samples also shown above.
3) Historical: GET /api/v1/historical
cURL:
JSON example and language samples shown in the historical section.
4) Time series: GET /api/v1/timeseries
cURL:
5) Fluctuation: GET /api/v1/fluctuation
cURL:
6) OHLC: GET /api/v1/ohlc
cURL:
7) Convert: GET /api/v1/convert
cURL:
Error responses and rate limiting
All errors return success=false and an error message. Common cases:
- 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 (e.g., wrong date format, invalid symbol like a misspelling of FED_DISCOUNT_RATE).
- 429: Request quota exhausted. Use Retry-After and log X-RateLimit-Limit, X-RateLimit-Remaining, X-RateLimit-Reset.
Production tip: Implement exponential backoff on 429; fail open with cached data for dashboards and fail closed for trading or model batch runs based on your risk posture.
Quick start and next steps
To try these endpoints, get your key and call the latest endpoint for FED_DISCOUNT_RATE. Then wire up /timeseries and /fluctuation for analytics, and /ohlc for charting. For cross-rate comparisons or loan-cost demos, integrate /convert. Explore more at interestratesapi.com, check the MCP, and Register to obtain your API key.
FAQ
How often does FED_DISCOUNT_RATE update in the API?
It’s a daily series. The value is available on business days and remains the same across days until an official change is published. Use /latest for the current effective value and /timeseries to see the sequence of daily observations.
What timezone are dates in?
Dates are ISO-8601 (Y-m-d) and represent the effective business date in UTC. Treat them as end-of-day effective stamps for daily financial reporting.
Can I compute a monthly payment from the returned percent?
Yes. Convert the annual percentage r to a monthly rate r/100/12, then apply the standard amortization formula. Always fetch the latest rate from /latest just before calculation to avoid stale inputs.
How do I handle missing data or holidays?
If you request a weekend/holiday via /historical, you receive the observation for that date in the daily index, which aligns with business-day effective values. For ranges with no data, the API may return 404 with details; handle this by shrinking the window or adjusting the start date.
What if I exceed my request quota?
You’ll receive 429 with Retry-After and X-RateLimit-* headers. Backoff and serve cached results. Log limits to right-size your polling strategy for /latest and /timeseries.
Register for Interest Rates API and start building. Review the models at the Interest Rates API MCP, or Get started with Interest Rates API by pulling FED_DISCOUNT_RATE into your finance app today.
