BKBM 3-Month Interest Rate Tracker: Historical Data & Trends

Building robust Finance applications requires reliable, precise, and developer-friendly interest rate data. Whether you are backtesting interbank spreads, calibrating cost-of-funds models, or piping benchmark rates into lending engines, the quality of your time series—its coverage, frequency, and query ergonomics—directly shapes model performance and end-user experience. This article presents a comprehensive, technically focused guide to tracking the New Zealand 3-Month Bank Bill Market (BKBM_3M) using interestratesapi.com. We focus on historical retrieval and time series analysis, demonstrate endpoint-by-endpoint integration patterns, and provide end-to-end code for developers working in Python, JavaScript, PHP, and cURL. Along the way, we break down response fields, common pitfalls (frequency mismatches, missing dates, and monthly aggregation edge cases), and practical strategies for analytics pipelines at scale.

If you need a single place to power dashboards, risk engines, and quantitative research with reliable benchmarks, interbank rates, treasury yields, and reference rates, interestratesapi.com provides a clean set of GET endpoints under a single base URL with simple query semantics and clear response structures. This lets you focus on model logic and performance—rather than bespoke data scrapers, data cleaning, and synchronization jobs. To explore capabilities or try live calls in minutes, visit:

Try Interest Rates API • Explore Interest Rates API features • Get started with Interest Rates API

Why the BKBM 3-Month benchmark matters for Finance applications

BKBM_3M is a core New Zealand interbank benchmark referencing the 3-month tenor on bank bills. Developers and analysts rely on this series to:

Estimate short-term NZD funding costs in treasury and ALM models.
Benchmark floating-rate NZD instruments and compute coupon resets or accruals.
Analyze interbank-liquidity conditions, evaluate central bank policy pass-through compared to RBNZ_OCR (when blending analyses), and quantify spreads versus other currencies’ 3M interbank tenors (e.g., EURIBOR_3M, BBSW_3M, or SARON_3M).
Drive quant dashboards for risk, performance attribution, and liquidity stress testing.

This article shows how to use interestratesapi.com to fetch, analyze, visualize, and export BKBM_3M. We will lead with multi-year time series using /timeseries, drill into point-in-time lookups via /historical, aggregate via /ohlc for candlestick visualizations, and build a full Python pipeline to turn API responses into CSV/Parquet outputs suitable for backtests and production data lakes.

Platform benefits for data engineers and quants

interestratesapi.com emphasizes:

Simplicity and consistency: A single base URL (https://interestratesapi.com/api/v1/) and a uniform GET method across all endpoints reduces integration complexity. Endpoints are predictable, composable, and easy to automate.
Developer ergonomics: Response structures return both values and essential metadata (currency, frequency, and data date mapping), which streamlines downstream validation and analysis.
Routing and reliability: Clear separation of endpoints (latest, historical, timeseries, fluctuation, ohlc) enables modular pipelines. You can implement robust orchestration patterns, retries with exponential backoff, and circuit breakers in your client—knowing the request semantics are stable.
Governance and observability: Per-application API usage can be isolated with per-app keys (you maintain these in your systems), enabling role-based access on your side. Response metadata helps with auditability in ETL/ELT logs, ensuring you can trace precisely which queries produced which datasets.
Performance at scale: The API’s focused design supports efficient batch requests (multiple symbols) and time-windowed queries, enabling predictable latency and lower egress in your data sync jobs.

Together, these qualities shorten your time-to-production, cut maintenance costs, and give you clean control points for deployment governance. For a hands-on start, visit:

Try Interest Rates API

Endpoint overview: What you can do with interestratesapi.com

All endpoints share a uniform style and are accessed with GET at the base URL https://interestratesapi.com/api/v1/. Below is a quick overview that we will expand on with detailed examples, JSON responses, and implementation techniques:

/symbols: Discover available rate symbols and filter by category, base currency, or provider.
/latest: Retrieve the most recent value(s) for one or more symbols.
/historical: Fetch the value for a specific date; for monthly series, the last day with data in that month is used.
/timeseries: Get a date-indexed time series between start and end for one or more symbols—ideal for modeling and backtests.
/fluctuation: Summarize change statistics over a date range (start value, end value, absolute/percentage change, high, low).
/ohlc: Compute open-high-low-close aggregates over time slices (weekly, monthly, or quarterly) derived from daily data; excellent for charting and regime analysis.
/convert: Compare loan interest costs between two symbols’ latest rates for a given amount and term—useful for pricing and what-if analysis.

In the sections that follow, we will deep dive into each endpoint with a hands-on lens focused on BKBM_3M.

Timeseries first: Multi-year BKBM_3M retrieval and analytics

The /timeseries endpoint is the backbone for any historical analysis workflow. It lets you retrieve BKBM_3M across a specified start and end date range, returning a date-indexed structure. This directly powers:

Rolling analytics: rolling means, volatilities, and drawdown metrics.
Signal pipelines: e.g., detecting rate trend inflections or building Carry-and-Roll models.
Liquidity and policy transmission studies: compare interbank shifts across macro events and policy decisions.
Dashboarding: feed timeseries to a front-end chart with minimal preprocessing.

How /timeseries works for BKBM_3M

BKBM_3M is an interbank series associated with NZD, typically treated as a daily or business-day frequency benchmark in production. The /timeseries endpoint returns a JSON object containing:

success: indicates a successful query.
base: the currency base context for the response (often USD for mixed sets, but the currency per symbol is provided too).
start_date and end_date: the parsed date boundaries of your query.
rates: a map of symbol to a date-to-value dictionary (e.g., { "2025-01-02": 5.33 }).
frequencies: the frequency tagging per symbol.
currencies: the currency code per symbol.

Below is a realistic JSON sample for a BKBM_3M range query:

{
"success": true,
"base": "USD",
"start_date": "2025-09-25",
"end_date": "2026-09-25",
"rates": {
"BKBM_3M": {
"2025-01-02": 5.33,
"2025-01-03": 5.33,
"2025-01-06": 5.33,
"2025-06-28": 5.41,
"2025-07-02": 5.42,
"2025-08-01": 5.40,
"2025-12-30": 5.36,
"2026-01-02": 5.35,
"2026-06-03": 5.34,
"2026-09-25": 5.33
}
},
"frequencies": { "BKBM_3M": "daily" },
"currencies": { "BKBM_3M": "USD" }
}

Field interpretations and practical uses:

rates → BKBM_3M → date:value: Your primary analysis vector. Feed these into pandas, R, or JavaScript arrays to compute rolling windows, z-scores, or regressions against macro variables.
frequencies.BKBM_3M: Critical for downstream logic. If frequency is "daily" but some dates are absent (weekends/holidays), you must decide on forward-filling or business-day calendars before computing rolling metrics.
currencies.BKBM_3M: Ensures currency consistency in multi-symbol analyses. While BKBM is NZD-contextual, the currency field in the example is "USD" as per the sample; your application should rely on this field when mixing symbols.

Timeseries query examples for BKBM_3M

cURL:

curl "https://interestratesapi.com/api/v1/timeseries?start=2025-09-25&end=2026-09-25&symbols=BKBM_3M&api_key=YOUR_KEY"

Python (requests):

import requests

resp = requests.get(
"https://interestratesapi.com/api/v1/timeseries",
params=dict(start="2025-09-25", end="2026-09-25", symbols="BKBM_3M", api_key="YOUR_KEY")
)
data = resp.json()
print(data["rates"]["BKBM_3M"])

JavaScript (fetch):

const response = await fetch(
"https://interestratesapi.com/api/v1/timeseries?start=2025-09-25&end=2026-09-25&symbols=BKBM_3M&api_key=YOUR_KEY"
);
const data = await response.json();
console.log(data.rates.BKBM_3M);

PHP:

<?php
$url = "https://interestratesapi.com/api/v1/timeseries?start=2025-09-25&end=2026-09-25&symbols=BKBM_3M&api_key=YOUR_KEY";
$response = file_get_contents($url);
$data = json_decode($response, true);
print_r($data["rates"]["BKBM_3M"]);
?

Performance and reliability tips:

Split long histories into annual chunks in parallel jobs to accelerate ingestion while staying within your infrastructure’s concurrency and retry strategies. Then merge locally into canonical time series.
Store raw JSON snapshots alongside normalized tables; this makes audit and reproducibility straightforward.
Validate frequencies on ingestion and enforce a business-day calendar to avoid distortion in rolling metrics.

To explore more capabilities, visit:

Explore Interest Rates API features

Historical point-in-time lookups: /historical edge cases

The /historical endpoint is a surgical tool for point-in-time values. This is crucial when you need the BKBM_3M rate as-of a specific date to backfill a ledger, compute accruals, or validate past pricing decisions. For BKBM_3M and other daily-frequency series, the API returns the value for the specified date if available. For monthly symbols, the endpoint uses the last day with data within that month. This design addresses real-world data publishing schedules and market holidays.

Key behaviors to consider:

If you request a weekend or public holiday for a daily series, ensure your system expects that no observation may exist for that day, depending on the symbol’s publication.
For monthly symbols, you can safely query any date within a month; the endpoint will return the last available observation inside that month. This simplifies month-end backfills and month-on-month comparisons.
When exact point-in-time accuracy matters (T+1 processes, EOD reconciliations), align your lookups with known publication calendars or supplement with /timeseries queries around the target date.

JSON example for BKBM_3M historical:

{
"success": true,
"date": "2025-06-15",
"base": "USD",
"rates": { "BKBM_3M": 5.33 },
"currencies": { "BKBM_3M": "USD" }
}

Endpoint usage examples:

cURL:

curl "https://interestratesapi.com/api/v1/historical?date=2025-06-15&symbols=BKBM_3M&api_key=YOUR_KEY"

Python:

import requests

resp = requests.get(
"https://interestratesapi.com/api/v1/historical",
params=dict(date="2025-06-15", symbols="BKBM_3M", api_key="YOUR_KEY")
)
print(resp.json())

JavaScript:

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

PHP:

<?php
$url = "https://interestratesapi.com/api/v1/historical?date=2025-06-15&symbols=BKBM_3M&api_key=YOUR_KEY";
$data = json_decode(file_get_contents($url), true);
print_r($data);
?

Practical guidance:

Design your application to gracefully handle missing dates for daily series (e.g., forward-fill or nearest-business-day rules) and document this logic in your analytics codebase.
When you need the end-of-month observation for reporting, monthly symbol behavior is ideal; for daily series, prefer querying the exact business day of the month-end or using /timeseries to compute month-end from the last trading day.

OHLC candlesticks for Finance dashboards: /ohlc endpoint and Chart.js integration

Candlestick aggregation is a staple for financial visualization: it compresses daily volatility into interpretable open-high-low-close windows. The /ohlc endpoint exposes OHLC built on-the-fly from daily data, allowing weekly, monthly, or quarterly views—without you maintaining a separate aggregation layer. For BKBM_3M, OHLC is helpful when:

You want to visualize rate regimes over months/quarters and quickly identify tops, troughs, and trend accelerations.
You need clean “open” and “close” definitions to align with portfolio snapshots or monthly roll projections.

Example JSON for BKBM_3M monthly candles:

{
"success": true,
"period": "monthly",
"start_date": "2025-09-25",
"end_date": "2026-09-25",
"rates": {
"BKBM_3M": [
{
"period": "2025-01",
"open": 5.50,
"high": 5.50,
"low": 5.33,
"close": 5.33,
"data_points": 23
},
{
"period": "2025-02",
"open": 5.33,
"high": 5.41,
"low": 5.32,
"close": 5.38,
"data_points": 20
}
]
}
}

Field meanings and usage:

period: the aggregated bucket identifier (e.g., 2025-01). Map to x-axis labels in your charts.
open, high, low, close: standard OHLC values within the period. Use close for EOM comparisons, high/low for intraperiod risk bands.
data_points: count of underlying daily observations in the aggregation window—vital for data quality. Low counts may indicate holidays or partial months; annotate chart tooltips accordingly.

OHLC usage examples:

cURL:

curl "https://interestratesapi.com/api/v1/ohlc?symbols=BKBM_3M&period=monthly&start=2025-09-25&end=2026-09-25&api_key=YOUR_KEY"

Python:

import requests

resp = requests.get(
"https://interestratesapi.com/api/v1/ohlc",
params=dict(symbols="BKBM_3M", period="monthly", start="2025-09-25", end="2026-09-25", api_key="YOUR_KEY")
)
ohlc = resp.json()
print(ohlc["rates"]["BKBM_3M"][:2])

JavaScript:

const res = await fetch(
"https://interestratesapi.com/api/v1/ohlc?symbols=BKBM_3M&period=monthly&start=2025-09-25&end=2026-09-25&api_key=YOUR_KEY"
);
const data = await res.json();
console.log(data.rates.BKBM_3M);

PHP:

<?php
$url = "https://interestratesapi.com/api/v1/ohlc?symbols=BKBM_3M&period=monthly&start=2025-09-25&end=2026-09-25&api_key=YOUR_KEY";
$data = json_decode(file_get_contents($url), true);
print_r($data["rates"]["BKBM_3M"]);
?

Chart.js integration snippet for BKBM_3M OHLC

Below is a minimal Chart.js integration for a candlestick-style display using OHLC data. It fetches monthly BKBM_3M candles and builds an OHLC bar chart. You can adapt this snippet for Plotly as well.

<!-- Include Chart.js and a financial chart plugin (e.g., chartjs-chart-financial) -->
<script src="https://cdn.jsdelivr.net/npm/chart.js" defer></script>
<script src="https://cdn.jsdelivr.net/npm/chartjs-chart-financial" defer></script>

<canvas id="bkbmChart" width="900" height="400"></canvas>

<script>
(async () => {
const url = "https://interestratesapi.com/api/v1/ohlc?symbols=BKBM_3M&period=monthly&start=2025-01-01&end=2026-12-31&api_key=YOUR_KEY";
const res = await fetch(url);
const json = await res.json();
const candles = json.rates.BKBM_3M.map(row => ({
x: row.period + "-01",
o: row.open,
h: row.high,
l: row.low,
c: row.close
}));

const ctx = document.getElementById("bkbmChart").getContext("2d");
new Chart(ctx, {
type: "candlestick",
data: {
datasets: [{
label: "BKBM 3M (Monthly OHLC)",
data: candles,
borderColor: "#2c3e50"
}]
},
options: {
plugins: {
tooltip: {
callbacks: {
label: (context) => {
const v = context.raw;
return `O:${v.o.toFixed(2)} H:${v.h.toFixed(2)} L:${v.l.toFixed(2)} C:${v.c.toFixed(2)}`;
}
}
}
},
scales: {
x: { type: "time", time: { unit: "month" } },
y: { title: { display: true, text: "Percent" } }
}
}
});
})();
</script>

Tip: Use data_points to annotate low-liquidity periods (holidays, partial months). In advanced dashboards, encode data_points as a bar background intensity or a tooltip note, helping users interpret candle stability.

Latest values for dashboards and alerts: /latest endpoint

While analytics often require deep history, production apps also need the current BKBM_3M level for dashboards, risk triggers, or pricing UIs. The /latest endpoint returns the most recent observation per symbol alongside the date and currency metadata. Use it to:

Drive top-line KPI cards and alert modules.
Compute instantaneous spreads versus other policy or interbank rates (e.g., compare BKBM_3M with ECB_MRO or FED_FUNDS in cross-market analysis).
Seed initial values for front-end charts before loading longer timeseries.

Example JSON:

{
"success": true,
"date": "2026-09-25",
"base": "MIXED",
"rates": {
"BKBM_3M": 5.33,
"ECB_MRO": 4.50
},
"dates": {
"BKBM_3M": "2026-09-25",
"ECB_MRO": "2026-09-25"
},
"currencies": {
"BKBM_3M": "USD",
"ECB_MRO": "EUR"
}
}

Notice:

rates maps symbols to the most recent value.
dates provides the exact observation date for each symbol (crucial when mixing assets with different publication times).
currencies specifies the currency per symbol, enabling cross-currency analytics logic in your application.

Usage examples:

cURL:

curl "https://interestratesapi.com/api/v1/latest?symbols=BKBM_3M,ECB_MRO&api_key=YOUR_KEY"

Python:

import requests

resp = requests.get(
"https://interestratesapi.com/api/v1/latest",
params=dict(symbols="BKBM_3M,ECB_MRO", api_key="YOUR_KEY")
)
print(resp.json())

JavaScript:

const response = await fetch(
"https://interestratesapi.com/api/v1/latest?symbols=BKBM_3M,ECB_MRO&api_key=YOUR_KEY"
);
const data = await response.json();
console.log(data.rates.BKBM_3M);

PHP:

<?php
$url = "https://interestratesapi.com/api/v1/latest?symbols=BKBM_3M,ECB_MRO&api_key=YOUR_KEY";
$data = json_decode(file_get_contents($url), true);
echo $data["rates"]["BKBM_3M"];
?

Symbol discovery: /symbols catalogue

Before committing to production logic, it’s best practice to verify symbol availability, categories, and metadata. The /symbols endpoint lets you filter by category, base currency, or provider to discover supported benchmarks. For BKBM_3M, querying by category=interbank is a quick way to explore adjacent tenors or comparable interbank series in other currencies.

Example filtered query:

curl "https://interestratesapi.com/api/v1/symbols?category=interbank&base=NZD&api_key=YOUR_KEY"

Generic JSON example:

{
"success": true,
"count": 2,
"symbols": [
{
"symbol": "BKBM_3M",
"name": "New Zealand Bank Bill Market Rate 3-Month",
"category": "interbank",
"country_code": "NZ",
"currency_code": "NZD",
"frequency": "daily",
"description": "3-month New Zealand bank bill market interbank rate"
},
{
"symbol": "RBNZ_OCR",
"name": "New Zealand Official Cash Rate",
"category": "central_bank",
"country_code": "NZ",
"currency_code": "NZD",
"frequency": "daily",
"description": "Official Cash Rate set by the Reserve Bank of New Zealand"
}
]
}

Use cases:

Automated symbol validation during CI/CD to catch typos before deployment.
Dynamic UIs that enumerate available instruments by category/country.
Maintaining symbol dictionaries in your data contracts to standardize naming across teams.

More discovery options are available at:

Get started with Interest Rates API

Change statistics and risk summaries: /fluctuation

Beyond raw time series, many Finance use cases require a compact summary of how a rate has changed across a defined window—ideal for executive reports, VaR or sensitivity narratives, and alert systems. The /fluctuation endpoint provides start and end values, absolute and percentage changes, as well as high and low observed values in the period.

Example JSON for BKBM_3M:

{
"success": true,
"rates": {
"BKBM_3M": {
"start_date": "2025-09-25",
"end_date": "2026-09-25",
"start_value": 5.50,
"end_value": 5.33,
"change": -0.17,
"change_pct": -3.09,
"high": 5.50,
"low": 5.25
}
}
}

Interpretation:

change and change_pct: Present headline movements in dashboards and daily e-mails. negative or positive sign indicates direction; compute color coding on the front end.
high and low: Visualize intraperiod risk envelope and identify if end_value is near extremes (useful for regime assessment).
start_date and end_date: Echo back your inputs for precise audit and result caching.

Usage examples:

cURL:

curl "https://interestratesapi.com/api/v1/fluctuation?start=2025-09-25&end=2026-09-25&symbols=BKBM_3M&api_key=YOUR_KEY"

Python:

import requests

resp = requests.get(
"https://interestratesapi.com/api/v1/fluctuation",
params=dict(start="2025-09-25", end="2026-09-25", symbols="BKBM_3M", api_key="YOUR_KEY")
)
print(resp.json()["rates"]["BKBM_3M"])

JavaScript:

const res = await fetch(
"https://interestratesapi.com/api/v1/fluctuation?start=2025-09-25&end=2026-09-25&symbols=BKBM_3M&api_key=YOUR_KEY"
);
const data = await res.json();
console.log(data.rates.BKBM_3M);

PHP:

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

Loan interest comparison for pricing insights: /convert

Though BKBM_3M is an interbank benchmark rather than a retail lending rate, it is often used as a reference for pricing components, hedging, or cross-market comparisons. The /convert endpoint computes the total interest cost of a simple loan at the latest rates for two symbols. You can, for instance, compare a hypothetical NZD loan at BKBM_3M’s latest level with a policy rate like ECB_MRO for a cross-currency illustration.

Example JSON:

{
"success": true,
"amount": 100000,
"term_months": 12,
"from": {
"symbol": "BKBM_3M",
"rate": 5.33,
"date": "2026-09-25",
"total_interest": 5330.00,
"total_payment": 105330.00
},
"to": {
"symbol": "ECB_MRO",
"rate": 4.50,
"date": "2026-09-25",
"total_interest": 4500.00,
"total_payment": 104500.00
},
"difference": {
"rate_spread": 0.83,
"interest_saved": 830.00
}
}

Use cases:

Quick what-if analyses and communication with stakeholders.
Pricing prototypes for lending desks to gauge sensitivity to benchmark shifts.
Dashboard tiles that contextualize benchmark changes in money terms.

Examples:

cURL:

curl "https://interestratesapi.com/api/v1/convert?from=BKBM_3M&to=ECB_MRO&amount=100000&term_months=12&api_key=YOUR_KEY"

Python:

import requests

resp = requests.get(
"https://interestratesapi.com/api/v1/convert",
params=dict(from="BKBM_3M", to="ECB_MRO", amount=100000, term_months=12, api_key="YOUR_KEY")
)
print(resp.json())

JavaScript:

const res = await fetch(
"https://interestratesapi.com/api/v1/convert?from=BKBM_3M&to=ECB_MRO&amount=100000&term_months=12&api_key=YOUR_KEY"
);
const data = await res.json();
console.log(data);

PHP:

<?php
$url = "https://interestratesapi.com/api/v1/convert?from=BKBM_3M&to=ECB_MRO&amount=100000&term_months=12&api_key=YOUR_KEY";
$data = json_decode(file_get_contents($url), true);
print_r($data);
?

Full Python pipeline: Fetch → pandas DataFrame → CSV/Parquet

A robust data engineering flow fetches BKBM_3M via /timeseries, normalizes dates, handles missing observations, and exports to both CSV and Parquet for downstream analytics. The snippet below demonstrates a minimal but production-minded approach, including validation and metadata capture. You can embed this logic into Airflow/Dagster tasks or cron-based ETL scripts.

import os
import json
import requests
import pandas as pd
from datetime import datetime

API_BASE = "https://interestratesapi.com/api/v1/"
API_KEY = os.environ.get("INTEREST_RATES_API_KEY", "YOUR_KEY")
SYMBOL = "BKBM_3M"

def fetch_timeseries(symbol: str, start: str, end: str) -> dict:
url = f"{API_BASE}timeseries"
params = dict(symbols=symbol, start=start, end=end, api_key=API_KEY)
resp = requests.get(url, params=params, timeout=30)
resp.raise_for_status()
data = resp.json()
if not data.get("success"):
raise RuntimeError(f"API failure: {data}")
return data

def normalize_to_df(ts_json: dict, symbol: str) -> pd.DataFrame:
rates = ts_json["rates"][symbol]
freq = ts_json["frequencies"].get(symbol)
ccy = ts_json["currencies"].get(symbol)

# Create DataFrame
df = pd.DataFrame(
[{"date": k, "value": v} for k, v in rates.items()]
).sort_values("date")

# Convert to datetime
df["date"] = pd.to_datetime(df["date"])
df["symbol"] = symbol
df["frequency"] = freq
df["currency"] = ccy

# Enforce business-day index if needed (optional forward-fill)
# Example: reindex to business days between min and max
bdays = pd.bdate_range(df["date"].min(), df["date"].max(), name="date")
df = df.set_index("date").reindex(bdays)
# Forward-fill missing values for business days with no observations
df["value"] = df["value"].ffill()
df["symbol"] = df["symbol"].ffill()
df["frequency"] = df["frequency"].ffill()
df["currency"] = df["currency"].ffill()
df = df.reset_index()

return df

def export_outputs(df: pd.DataFrame, out_dir: str) -> None:
os.makedirs(out_dir, exist_ok=True)
# CSV
csv_path = os.path.join(out_dir, "BKBM_3M_timeseries.csv")
df.to_csv(csv_path, index=False)
# Parquet
pq_path = os.path.join(out_dir, "BKBM_3M_timeseries.parquet")
df.to_parquet(pq_path, index=False)
print(f"Exported: {csv_path} and {pq_path}")

def main():
start, end = "2024-01-01", datetime.utcnow().strftime("%Y-%m-%d")
ts_json = fetch_timeseries(SYMBOL, start, end)
df = normalize_to_df(ts_json, SYMBOL)

# Attach provenance metadata
meta = {
"source": "interestratesapi.com",
"symbol": SYMBOL,
"start_date": ts_json.get("start_date"),
"end_date": ts_json.get("end_date"),
"fetched_at": datetime.utcnow().isoformat()
}

# Write metadata
out_dir = "./data_bkbm_3m"
os.makedirs(out_dir, exist_ok=True)
with open(os.path.join(out_dir, "metadata.json"), "w") as f:
json.dump(meta, f, indent=2)

export_outputs(df, out_dir)

if __name__ == "__main__":
main()

Notes:

The pipeline forward-fills missing business days for analytics stability—which is common in Finance. Document this choice so downstream users interpret results correctly.
Both CSV and Parquet are generated for broad compatibility; Parquet is typically preferred in lakehouses for efficient columnar storage and predicate pushdown.
Metadata is recorded alongside the dataset to support auditing and reproducibility.

Time series pitfalls and best practices

Real-world financial time series are imperfect. Here is a checklist to keep your BKBM_3M workflows robust:

Missing dates: Interbank series may skip weekends and holidays. Decide early on a calendar strategy: forward-fill business days, nearest observation rules, or leave gaps for analysis pipelines that explicitly handle them.
Daily vs monthly: When using /historical on a monthly symbol, the endpoint returns the last day with data in that month. Don’t treat that series as a naïve daily series—use /timeseries for true daily modeling.
data_points in OHLC: Low counts imply fewer underlying observations in that aggregation period. Surface this in dashboards so analysts know when candles represent partial data.
Mixed currency contexts: If you compare BKBM_3M with other symbols, confirm currency codes via currencies in responses. Align with your FX normalization strategy if mixing cross-currency metrics or returns.
Window endpoints: When calculating rolling stats, account for off-calendar gaps. For example, a 20-day rolling mean might correspond to roughly a month of business days; parameterize windows accordingly.

Complete endpoint-by-endpoint reference with examples

1) /symbols — Catalogue of available rate symbols

Purpose: Discover symbols, filter by currency, category, or provider, and validate availability before deploying analytics or UI components.

Request:

curl "https://interestratesapi.com/api/v1/symbols?category=interbank&base=NZD&api_key=YOUR_KEY"

Python:

import requests
r = requests.get(
"https://interestratesapi.com/api/v1/symbols",
params=dict(category="interbank", base="NZD", api_key="YOUR_KEY")
)
symbols = r.json()
print(symbols)

JavaScript:

const res = await fetch(
"https://interestratesapi.com/api/v1/symbols?category=interbank&base=NZD&api_key=YOUR_KEY"
);
const data = await res.json();
console.log(data.symbols);

PHP:

<?php
$url = "https://interestratesapi.com/api/v1/symbols?category=interbank&base=NZD&api_key=YOUR_KEY";
$data = json_decode(file_get_contents($url), true);
print_r($data["symbols"]);
?

JSON example (annotated above) shows fields like symbol, name, category, country_code, currency_code, frequency, description. These support dictionary generation, UI labeling, and documentation syncing across teams.

2) /latest — Latest value per symbol

Purpose: Power live dashboards, alerts, and spread comparisons with current observations.

Request:

curl "https://interestratesapi.com/api/v1/latest?symbols=BKBM_3M&api_key=YOUR_KEY"

Response fields: success, date, base, rates, dates, currencies. Combine dates and rates for precise observation timestamps. Use currencies to avoid cross-currency confusion.

3) /historical — Value on a specific date

Purpose: Backfills, reconciliations, point-in-time valuations, and EOM reporting. Monthly symbols return the last day with data within that month.

Request:

curl "https://interestratesapi.com/api/v1/historical?date=2025-06-15&symbols=BKBM_3M&api_key=YOUR_KEY"

Response fields: success, date, base, rates, currencies. Edge cases include weekends/holidays for daily series; handle gracefully.

4) /timeseries — Series between two dates

Purpose: Backtests, rolling analytics, quant studies, and charting histories. It returns date-to-value maps plus frequency and currency metadata.

Request:

curl "https://interestratesapi.com/api/v1/timeseries?start=2025-01-01&end=2026-12-31&symbols=BKBM_3M&api_key=YOUR_KEY"

Response fields: success, base, start_date, end_date, rates (date:value dictionary), frequencies, currencies. Use this to build canonical time-indexed tables for modeling.

5) /fluctuation — Change statistics over a range

Purpose: Executive summaries, alerting, and top-line movement analytics. It reports start/end values and extremes within the window.

Request:

curl "https://interestratesapi.com/api/v1/fluctuation?start=2025-09-25&end=2026-09-25&symbols=BKBM_3M&api_key=YOUR_KEY"

Response fields: start_date, end_date, start_value, end_value, change, change_pct, high, low. Pair with OHLC for both macro and micro views of rate movement.

6) /ohlc — OHLC candlestick data

Purpose: Visualization and regime analysis on weekly/monthly/quarterly horizons. It computes OHLC from daily data dynamically—no separate storage required.

Request:

curl "https://interestratesapi.com/api/v1/ohlc?symbols=BKBM_3M&period=monthly&start=2025-01-01&end=2026-12-31&api_key=YOUR_KEY"

Response fields: period, open, high, low, close, data_points. Validate data_points to flag partial months in UI tooltips.

7) /convert — Loan interest cost comparison

Purpose: Prototype pricing and what-if analyses. Compares the total interest on a simple loan using the latest values from two symbols.

Request:

curl "https://interestratesapi.com/api/v1/convert?from=BKBM_3M&to=ECB_MRO&amount=250000&term_months=24&api_key=YOUR_KEY"

Response fields: amount, term_months, from{symbol, rate, date, total_interest, total_payment}, to{...}, difference{rate_spread, interest_saved}. Embed results directly in UI panels and e-mails.

End-to-end examples: Combined workflow for Finance teams

Imagine a quant or data engineer building a cross-market funding dashboard. The workflow might be:

Use /symbols to validate BKBM_3M and discover related interbank rates across currencies for comparative panels.
Use /timeseries to fetch the BKBM_3M history and compute rolling spreads to EURIBOR_3M or BBSW_3M.
Use /ohlc to visualize monthly regimes and quickly spot periods of elevated volatility.
Use /fluctuation to produce monthly or quarterly executive summaries: net change, percent move, and extremes.
Use /latest to power live KPIs and trigger slack/alert thresholds.
Optionally, use /convert to communicate rate differences in money terms—helpful for non-technical stakeholders.

By leveraging a single, consistent API, your team avoids stitching together multiple data vendors and formats, reducing both failure points and operational overhead.

Common error handling and troubleshooting patterns

Interpreting error responses consistently simplifies retries and user messaging. The API returns a clear error shape with success=false and an error message string. Here are typical cases:

401: Invalid or missing credentials. Ensure your request includes the required query parameter.
403: Account not authorized for the requested access. In your client, present a clear message and log for ops review.
404: No symbols matched or no data for the requested date/range. Read any details in the response to determine the available ranges; update your UI or expand the range accordingly.
422: Validation error (e.g., date format or invalid symbol). Validate inputs client-side and sanitize before retrying.

Example error response shape:

{
"success": false,
"error": "No data for the requested date",
"details": "BKBM_3M available from 1999-01-04 to 2026-09-25"
}

Best practices:

Create a typed error model in your client libraries to handle each status code explicitly.
For 404 with details, automatically adjust the date range and offer a one-click “retry with available range” in the UI.
For 422, implement inline form validation (e.g., YYYY-MM-DD for date inputs).
Log requests and responses for observability; include timestamp, endpoint, query params, and parsed error fields to support rapid triage.

Security, governance, and reliability in Finance-grade integrations

Institutional Finance applications demand strict governance and resilience. interestratesapi.com’s consistent GET semantics and structured responses make it easier to:

Enforce per-application separation in your own systems, with explicit roles for data ingestion services, analytics notebooks, and dashboard UIs.
Build safe retry policies with exponential backoff and jitter in your HTTP client to handle transient network issues without overloading systems.
Add health checks for your pipelines that verify symbol availability (/symbols) and smoke-test core endpoints (/latest, /timeseries) during deployment.
Implement circuit breakers in your orchestration (e.g., fallback to cached data if a live call fails) to preserve application uptime.
Maintain audit logs that capture query params and hash of response payloads; this supports compliance narratives for risk reporting.

These operational patterns, coupled with straightforward response formats, reduce downtime risk and facilitate rapid incident response—critical in production Finance environments.

BKBM 3-Month scenarios: Real-world applications

Here are practical scenarios where BKBM_3M data can add immediate value:

Loan and deposit pricing engines: Use /latest to set current benchmark spreads. Precompute monthly OHLC to explain pricing movements to customers or relationship managers.
ALM balance sheet analytics: Pull /timeseries daily history to build duration and gap models; compute sensitivities to BKBM_3M shocks and compare to central bank paths.
Hedge effectiveness testing: Track hedging instruments linked to 3M NZD benchmarks; compare realized funding costs vs. BKBM_3M across horizons using /fluctuation outputs.
Macro strategy and research: Combine BKBM_3M with other interbank series (e.g., EURIBOR_3M, BBSW_3M, SARON_3M) to study cross-market dynamics. Use consistent OHLC to align monthly narratives across currencies.

Additional complete JSON examples for clarity

To solidify understanding, below are additional realistic JSON examples with fields commonly used in production logic.

Timeseries multi-symbol example (BKBM_3M and EURIBOR_3M)

{
"success": true,
"base": "USD",
"start_date": "2025-01-01",
"end_date": "2025-01-31",
"rates": {
"BKBM_3M": {
"2025-01-02": 5.33,
"2025-01-03": 5.33,
"2025-01-06": 5.33,
"2025-01-07": 5.34,
"2025-01-08": 5.34,
"2025-01-09": 5.34
},
"EURIBOR_3M": {
"2025-01-02": 3.90,
"2025-01-03": 3.91,
"2025-01-06": 3.91,
"2025-01-07": 3.92,
"2025-01-08": 3.92,
"2025-01-09": 3.93
}
},
"frequencies": {
"BKBM_3M": "daily",
"EURIBOR_3M": "daily"
},
"currencies": {
"BKBM_3M": "USD",
"EURIBOR_3M": "EUR"
}
}

OHLC quarterly example

{
"success": true,
"period": "quarterly",
"start_date": "2025-01-01",
"end_date": "2025-12-31",
"rates": {
"BKBM_3M": [
{ "period": "2025-Q1", "open": 5.33, "high": 5.45, "low": 5.32, "close": 5.40, "data_points": 62 },
{ "period": "2025-Q2", "open": 5.40, "high": 5.44, "low": 5.35, "close": 5.38, "data_points": 64 },
{ "period": "2025-Q3", "open": 5.38, "high": 5.42, "low": 5.34, "close": 5.36, "data_points": 66 },
{ "period": "2025-Q4", "open": 5.36, "high": 5.39, "low": 5.33, "close": 5.35, "data_points": 62 }
]
}
}

Fluctuation multi-symbol example

{
"success": true,
"rates": {
"BKBM_3M": {
"start_date": "2025-01-01",
"end_date": "2025-12-31",
"start_value": 5.33,
"end_value": 5.35,
"change": 0.02,
"change_pct": 0.38,
"high": 5.45,
"low": 5.32
},
"EURIBOR_3M": {
"start_date": "2025-01-01",
"end_date": "2025-12-31",
"start_value": 3.90,
"end_value": 3.85,
"change": -0.05,
"change_pct": -1.28,
"high": 3.95,
"low": 3.80
}
}
}

Practical coding patterns and tips for Finance-grade apps

Schema-first development: Define your canonical DataFrame or table schema (date, symbol, value, frequency, currency, source, fetched_at). Enforce dtype constraints and null rules in validation tests.
Idempotent ETL: Write ingestion jobs so repeated runs don’t duplicate data; consider upsert-by-date for each symbol.
Provenance tagging: Always store response metadata (start_date, end_date, frequency, and currencies) with your dataset for traceability and easier audits.
Testing with golden files: Capture known responses for small date ranges and assert equality in CI. This prevents breaking changes in your transform code.
Visualization hygiene: Round values consistently and label axes with units. Use close values in OHLC for returns or MoM calculations unless your methodology states otherwise.

End-to-end sample: From discovery to chart in minutes

Putting it all together:

Call /symbols to confirm BKBM_3M and related interbank series are present for NZD.
Load multi-year BKBM_3M history via /timeseries; normalize in pandas; export CSV/Parquet for future reuse.
Generate OHLC via /ohlc for monthly regimes and wire into a Chart.js front-end panel.
Summarize changes over the last quarter via /fluctuation for executive reporting.
Surface the current BKBM_3M value via /latest in your header KPIs.

This approach yields an auditable, maintainable, and extensible interest-rate analytics stack—key for Finance teams who must move quickly while remaining rigorous.

Frequently asked technical questions

How do I handle holidays for daily series like BKBM_3M? Use a business-day calendar and decide on forward-fill vs. gap-respecting analytics based on your model’s needs. Document the choice.
Should I use monthly OHLC close for EOM snapshots? Yes, for visualization and high-level summaries. If your P&L is computed on specific trading days, derive EOM from /timeseries and your trading calendar.
Can I combine BKBM_3M with central bank rates like RBNZ_OCR for research? Yes—use /timeseries to fetch each series, confirm currencies and frequencies, and compute spreads or pass-through metrics. Ensure symbol names match those returned by /symbols.

Additional code gallery for BKBM_3M

Minimal pandas rolling window

import requests
import pandas as pd

url = "https://interestratesapi.com/api/v1/timeseries"
params = dict(start="2025-01-01", end="2026-09-25", symbols="BKBM_3M", api_key="YOUR_KEY")
data = requests.get(url, params=params).json()

series = data["rates"]["BKBM_3M"]
df = pd.DataFrame([{"date": d, "value": v} for d, v in series.items()])
df["date"] = pd.to_datetime(df["date"])
df = df.sort_values("date").set_index("date")

# 20-business-day rolling mean
df_rolled = df.rolling(window=20).mean().rename(columns={"value": "value_roll20"})
print(df_rolled.tail())

Client-side fetch with rendering hook

async function loadBKBM() {
const r = await fetch("https://interestratesapi.com/api/v1/latest?symbols=BKBM_3M&api_key=YOUR_KEY");
const j = await r.json();
const value = j.rates.BKBM_3M;
const asOf = j.dates.BKBM_3M;
document.getElementById("bkbmValue").textContent = `${value.toFixed(2)}% (as of ${asOf})`;
}
document.addEventListener("DOMContentLoaded", loadBKBM);

HTML target:

<div>BKBM 3M Latest: <span id="bkbmValue">Loading...</span></div>

Putting the pieces together for Finance

interestratesapi.com helps Finance teams avoid the heavy lifting of bespoke scrapers and partial datasets. With a clean GET-based surface and consistent JSON, you can build:

High-signal dashboards with monthly and quarterly OHLCs for BKBM_3M.
Backtests that rely on stable /timeseries retrieval and well-defined calendars.
Automated reporting fed by /fluctuation and seeded with /latest.
Data warehouses or lakehouses populated via Python pipelines, with CSV/Parquet outputs for interoperability across teams and tools.

The payoff is tangible: fewer moving parts, clearer governance, and faster time from research to production. To dive deeper, explore live examples and documentation at:

Try Interest Rates API • Explore Interest Rates API features • Get started with Interest Rates API

Appendix: Additional endpoint examples and notes

Symbols — alternate filters

Filter interbank instruments in EUR for cross-currency comparison:

curl "https://interestratesapi.com/api/v1/symbols?category=interbank&base=EUR&api_key=YOUR_KEY"

Sample response:

{
"success": true,
"count": 3,
"symbols": [
{
"symbol": "EURIBOR_1M",
"name": "EURIBOR 1-Month",
"category": "interbank",
"country_code": "EU",
"currency_code": "EUR",
"frequency": "daily",
"description": "Euro Interbank Offered Rate, 1-month tenor"
},
{
"symbol": "EURIBOR_3M",
"name": "EURIBOR 3-Month",
"category": "interbank",
"country_code": "EU",
"currency_code": "EUR",
"frequency": "daily",
"description": "Euro Interbank Offered Rate, 3-month tenor"
},
{
"symbol": "EURIBOR_6M",
"name": "EURIBOR 6-Month",
"category": "interbank",
"country_code": "EU",
"currency_code": "EUR",
"frequency": "daily",
"description": "Euro Interbank Offered Rate, 6-month tenor"
}
]
}

Latest — single-symbol fetch

curl "https://interestratesapi.com/api/v1/latest?symbols=BKBM_3M&api_key=YOUR_KEY"

Sample snippet of response handling in Python:

import requests
r = requests.get(
"https://interestratesapi.com/api/v1/latest",
params=dict(symbols="BKBM_3M", api_key="YOUR_KEY")
)
j = r.json()
print(f"{j['rates']['BKBM_3M']}% as of {j['dates']['BKBM_3M']}")

Historical — weekend edge case handling

If you query a Saturday, ensure your app either tolerates potential absence or consults adjacent business days with a local fallback:

import datetime as dt
import requests

def get_nearest_bday(date_str):
d = dt.datetime.strptime(date_str, "%Y-%m-%d").date()
while d.weekday() >= 5:
d -= dt.timedelta(days=1)
return d.strftime("%Y-%m-%d")

query_date = "2025-06-14" # Saturday
adj_date = get_nearest_bday(query_date)
resp = requests.get(
"https://interestratesapi.com/api/v1/historical",
params=dict(date=adj_date, symbols="BKBM_3M", api_key="YOUR_KEY")
)
print(resp.json())

Timeseries — multi-year chunking pattern

import requests
import pandas as pd
from datetime import date

def chunk_years(start_year, end_year):
for y in range(start_year, end_year + 1):
yield f"{y}-01-01", f"{y}-12-31" if y < end_year else date.today().strftime("%Y-%m-%d")

frames = []
for s, e in chunk_years(2018, 2026):
r = requests.get(
"https://interestratesapi.com/api/v1/timeseries",
params=dict(start=s, end=e, symbols="BKBM_3M", api_key="YOUR_KEY")
).json()
series = r["rates"]["BKBM_3M"]
df = pd.DataFrame([{"date": d, "value": v} for d, v in series.items()])
frames.append(df)

full = pd.concat(frames).drop_duplicates(subset=["date"]).sort_values("date")
print(full.head(), full.tail())

OHLC — weekly candles for high-resolution visuals

curl "https://interestratesapi.com/api/v1/ohlc?symbols=BKBM_3M&period=weekly&start=2025-01-01&end=2025-06-30&api_key=YOUR_KEY"

Render in Chart.js or Plotly. Weekly candles provide finer-grain regime views than monthly, particularly around policy announcements or liquidity shocks.

Conclusion

For developers, economists, quantitative analysts, and financial data engineers, BKBM_3M is a vital interbank benchmark for NZD funding, pricing, and macro insights. interestratesapi.com provides a cohesive, GET-only interface spanning discovery (/symbols), the present (/latest), point-in-time checks (/historical), long-form analytics (/timeseries), change summaries (/fluctuation), and visualization-ready aggregates (/ohlc). With these endpoints, you can produce production-grade pipelines and dashboards—fast—while maintaining auditability, reliability, and analytical rigor.

To continue exploring, experimenting, and building Finance applications powered by clean interest rate data, visit:

Try Interest Rates API • Explore Interest Rates API features • Get started with Interest Rates API

Why the BKBM 3-Month benchmark matters for Finance applications

Platform benefits for data engineers and quants

Endpoint overview: What you can do with interestratesapi.com

Timeseries first: Multi-year BKBM_3M retrieval and analytics

How /timeseries works for BKBM_3M

Timeseries query examples for BKBM_3M

Historical point-in-time lookups: /historical edge cases

OHLC candlesticks for Finance dashboards: /ohlc endpoint and Chart.js integration

Chart.js integration snippet for BKBM_3M OHLC

Latest values for dashboards and alerts: /latest endpoint

Symbol discovery: /symbols catalogue

Change statistics and risk summaries: /fluctuation

Loan interest comparison for pricing insights: /convert

Full Python pipeline: Fetch → pandas DataFrame → CSV/Parquet

Time series pitfalls and best practices

Complete endpoint-by-endpoint reference with examples

1) /symbols — Catalogue of available rate symbols

2) /latest — Latest value per symbol

3) /historical — Value on a specific date

4) /timeseries — Series between two dates

5) /fluctuation — Change statistics over a range

6) /ohlc — OHLC candlestick data

7) /convert — Loan interest cost comparison

End-to-end examples: Combined workflow for Finance teams

Common error handling and troubleshooting patterns

Security, governance, and reliability in Finance-grade integrations

BKBM 3-Month scenarios: Real-world applications

Additional complete JSON examples for clarity

Timeseries multi-symbol example (BKBM_3M and EURIBOR_3M)

OHLC quarterly example

Fluctuation multi-symbol example

Practical coding patterns and tips for Finance-grade apps

End-to-end sample: From discovery to chart in minutes

Frequently asked technical questions

Additional code gallery for BKBM_3M

Minimal pandas rolling window

Client-side fetch with rendering hook

Putting the pieces together for Finance

Appendix: Additional endpoint examples and notes

Symbols — alternate filters

Latest — single-symbol fetch

Historical — weekend edge case handling

Timeseries — multi-year chunking pattern

OHLC — weekly candles for high-resolution visuals

Conclusion

Ready to get started?

Related posts