Jakarta Interbank Offered Rate 3-Month Historical Data API: Timeseries, Charts & Downloads

Fintech applications, risk models, and macro research dashboards all depend on precise, auditable histories of benchmark interest rates. Whether you are tracking Jakarta Interbank Offered Rate 3-Month for liquidity signals in IDR money markets or validating central bank policy pass-through effects, the core challenges remain the same: assembling long-run time series, handling mixed frequencies, normalizing calendars, and producing production-ready outputs for downstream analytics. This article shows how to solve those problems end-to-end with interestratesapi.com, focusing on robust data retrieval patterns that scale from exploratory notebooks to enterprise systems. Although the title spotlights Jakarta Interbank Offered Rate 3-Month, the full workflow is demonstrated using the Reserve Bank of Australia Cash Rate Target (symbol: RBA_CASH_RATE) to illustrate key central bank rate concepts and API usage that apply equally to interbank benchmarks like JIBOR_3M (Jakarta Interbank Offered Rate 3-Month) and others in the symbol catalogue.

Why historical interest rate data is hard—and why APIs matter

Collecting high-quality historical interest rates involves more than just fetching yesterday’s value. Real-world pipelines must address long horizons, calendar differences, monthly vs daily series, and the need for efficient batch retrieval and transformation. Without a unified API:

• Developers waste time scraping disparate websites and parsing PDFs or CSV formats that change unexpectedly.
• Quant teams face reproducibility issues because identical queries on different sources yield different calendars and missing-data conventions.
• Product teams struggle to deliver charts and dashboards that reconcile daily, weekly, and monthly data—especially when some series update only a few times per month.
• Economists and risk managers lack consistent OHLC aggregations, making it difficult to implement candlestick charts, compute drawdowns, or detect structural breaks in regime changes.

interestratesapi.com addresses these issues with a simple, consistent set of endpoints for discovery, latest values, point-in-time queries, bulk time series pulls, range fluctuation summaries, and on-the-fly OHLC aggregation. You can integrate it directly into back-end jobs, front-end dashboards, or research notebooks to power everything from scenario analysis to automated alerts. Start exploring here: Try Interest Rates API, Explore Interest Rates API features, and Get started with Interest Rates API.

Symbol discovery: mapping your needs to the right benchmark

Before you fetch data, you need to confirm you have the correct symbol and metadata. The /symbols endpoint returns a catalogue you can filter by currency (base), category (central_bank, interbank, treasury, reference), or provider. For our central bank focus example, we will use RBA_CASH_RATE (Reserve Bank of Australia Cash Rate Target). For Jakarta money market analysis, you can also locate interbank symbols such as JIBOR_3M from the same catalogue and follow the exact same patterns demonstrated below.

Endpoint: GET /api/v1/symbols

Purpose: discover available benchmarks and their attributes for correct symbol selection and frequency awareness.

Key query parameters:

• base: ISO 3-letter currency code to filter series (e.g., AUD, IDR)
• category: central_bank, interbank, treasury, reference
• provider: fred, ecb, bis (optional)

Example cURL:

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

Example JSON response (truncated illustration):

{
"success": true,
"count": 1,
"symbols": [
{
"symbol": "RBA_CASH_RATE",
"name": "Reserve Bank of Australia Cash Rate Target",
"category": "central_bank",
"country_code": "AU",
"currency_code": "AUD",
"frequency": "monthly",
"description": "Target cash rate set by the Reserve Bank of Australia"
}
]
}

Field meanings and practical use:

• symbol: exact identifier to use in all other requests.
• frequency: tells you whether to expect daily, weekly, or monthly observations. For monthly series like RBA_CASH_RATE, the API maps to the last day with data in that month when querying specific dates.
• description/name/country_code/currency_code: metadata helpful for UI labels, data dictionaries, and governance documentation.

When targeting interbank rates such as Jakarta Interbank Offered Rate 3-Month (JIBOR_3M), you can filter category=interbank and base=IDR to discover related series. Although this article’s code focuses on RBA_CASH_RATE, you can swap in JIBOR_3M for IDR market analytics with the same endpoints and patterns.

Lead feature: building multi-year time series with /timeseries

The primary workhorse for analytics is the /timeseries endpoint, designed for multi-day to multi-year retrievals across one or more symbols. It is ideal for:

• Backfills when onboarding a new analytics product or risk model.
• Loading training data windows for machine learning feature engineering.
• Refreshing cache layers that power dashboards and internal APIs.

Endpoint: GET /api/v1/timeseries

Required parameters:

• start: YYYY-MM-DD
• end: YYYY-MM-DD (must be greater than or equal to start)
• symbols: comma-separated list (e.g., RBA_CASH_RATE or RBA_CASH_RATE,JIBOR_3M)

Optional:

• base: currency filter (useful if pulling mixed sets and you want to segment by base currency)

Example cURL for a one-year RBA cash rate pull:

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

Example JSON response:

{
"success": true,
"base": "USD",
"start_date": "2025-09-22",
"end_date": "2026-09-22",
"rates": {
"RBA_CASH_RATE": {
"2025-01-02": 5.33,
"2025-01-03": 5.33,
"2025-01-06": 5.33,
"2025-02-03": 5.33,
"2025-03-03": 5.33,
"2025-04-01": 5.33,
"2025-05-01": 5.33,
"2025-06-03": 5.33,
"2025-07-01": 5.33,
"2025-08-01": 5.33,
"2025-09-01": 5.33,
"2025-10-01": 5.33,
"2025-11-03": 5.33,
"2025-12-01": 5.33,
"2026-01-02": 5.33,
"2026-02-03": 5.33,
"2026-03-02": 5.33,
"2026-04-01": 5.33,
"2026-05-01": 5.33,
"2026-06-03": 5.33,
"2026-07-01": 5.33,
"2026-08-03": 5.33,
"2026-09-01": 5.33
}
},
"frequencies": { "RBA_CASH_RATE": "daily" },
"currencies": { "RBA_CASH_RATE": "USD" }
}

Response interpretation:

• rates: nested by symbol, then date, mapping to the rate value for that observation date.
• frequencies: informs your downstream aggregator or visualization pipeline whether to treat the series as daily or monthly. Even when a policy rate is effectively updated monthly, its representation can be mapped across business days depending on source conventions.
• currencies: currency codes associated with each rate, beneficial for multi-currency dashboards and portfolio analytics.

Tips:

• Date alignment: For models that require strict month-end alignment, consider resampling in your analytics layer to end-of-month values to avoid intra-month repetition artifacts.
• Multiple symbols: You can pass a list (e.g., symbols=RBA_CASH_RATE,JIBOR_3M) to co-load cross-market time series into the same structure and merge keys by date.

Example Python (requests) for timeseries:

import requests

url = 'https://interestratesapi.com/api/v1/timeseries'
params = dict(
start='2023-01-01',
end='2026-09-22',
symbols='RBA_CASH_RATE',
api_key='YOUR_KEY'
)
response = requests.get(url, params=params)
data = response.json()
print(data['success'], len(data['rates']['RBA_CASH_RATE']))

Example JavaScript (fetch) for timeseries:

const url = 'https://interestratesapi.com/api/v1/timeseries?start=2023-01-01&end=2026-09-22&symbols=RBA_CASH_RATE&api_key=YOUR_KEY';
const response = await fetch(url);
const data = await response.json();
console.log(data.success, Object.keys(data.rates['RBA_CASH_RATE']).length);

Example PHP for timeseries:

<?php
$endpoint = 'https://interestratesapi.com/api/v1/timeseries?start=2023-01-01&end=2026-09-22&symbols=RBA_CASH_RATE&api_key=YOUR_KEY';
$ch = curl_init($endpoint);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$result = curl_exec($ch);
curl_close($ch);
$data = json_decode($result, true);
echo $data['success'] ? 'OK' : 'Error';
?>

Point-in-time lookups with /historical: handling weekends, holidays, and monthly mapping

When you need the value on a specific date—for auditing, backtesting, or point-in-time accounting—the /historical endpoint is the right tool. For monthly symbols (such as many central bank policy targets), the API returns the last available day with data in that month for the provided date. This makes it convenient to query arbitrary dates without manually computing month boundaries.

Endpoint: GET /api/v1/historical

Required:

• date: YYYY-MM-DD

Optional:

• symbols: comma-separated list (e.g., RBA_CASH_RATE or RBA_CASH_RATE,JIBOR_3M)
• base: currency filter

Example cURL:

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

Example JSON response:

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

Key considerations:

• Monthly mapping: If the series frequency is monthly and you query 2025-06-15, the API returns the rate associated with the last valid date in June 2025 for that series—this helps avoid “no data” pitfalls on mid-month dates.
• Weekends and holidays: For daily series, most official rates do not trade on weekends/holidays; the API maps actual observation days only. For compliance-sensitive needs, always record the returned dates if provided and document your logic.

Example Python (requests) for historical:

import requests

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

Example JavaScript (fetch) for historical:

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

Example PHP for historical:

<?php
$url = 'https://interestratesapi.com/api/v1/historical?date=2025-06-15&symbols=RBA_CASH_RATE&api_key=YOUR_KEY';
$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$result = curl_exec($ch);
curl_close($ch);
echo $result;
?>

On-the-fly OHLC for candlestick charts with /ohlc (+ Chart.js integration)

Visualization and exploratory analysis benefit from OHLC structures—open, high, low, close—especially when you want to inspect intra-period changes (e.g., shifts within a month for daily series). Even for policy rates that change infrequently, OHLC plots can reveal timing and magnitude of adjustments across months or quarters. The /ohlc endpoint computes OHLC aggregations from underlying daily data on demand.

Endpoint: GET /api/v1/ohlc

Required:

• symbols: comma-separated list (e.g., RBA_CASH_RATE)

Optional:

• period: weekly | monthly | quarterly (default monthly)
• start: YYYY-MM-DD
• end: YYYY-MM-DD

Example cURL:

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

Example JSON response:

{
"success": true,
"period": "monthly",
"start_date": "2025-01-01",
"end_date": "2026-09-22",
"rates": {
"RBA_CASH_RATE": [
{
"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.33,
"low": 5.33,
"close": 5.33,
"data_points": 20
}
]
}
}

Field meanings:

• period: aggregation key in YYYY-MM for monthly (YYYY-WW or YYYY-Qn for other choices).
• open/high/low/close: computed from daily data within the specified period.
• data_points: count of daily observations used to compute OHLC—useful for validating gaps or short months.

Chart.js integration snippet (front-end):

<canvas id="ohlcChart" width="800" height="400"></canvas>
<script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
<script>
(async function() {
const url = 'https://interestratesapi.com/api/v1/ohlc?symbols=RBA_CASH_RATE&period=monthly&start=2025-01-01&end=2026-09-22&api_key=YOUR_KEY';
const resp = await fetch(url);
const json = await resp.json();
const rows = json.rates['RBA_CASH_RATE'];

const labels = rows.map(r => r.period);
const dataHigh = rows.map(r => r.high);
const dataLow = rows.map(r => r.low);
const dataOpen = rows.map(r => r.open);
const dataClose = rows.map(r => r.close);

// Simple overlay plot: high/low bands and open/close lines
const ctx = document.getElementById('ohlcChart').getContext('2d');
new Chart(ctx, {
type: 'line',
data: {
labels,
datasets: [
{ label: 'High', data: dataHigh, borderColor: 'rgba(220, 53, 69, 0.9)', fill: false },
{ label: 'Low', data: dataLow, borderColor: 'rgba(25, 135, 84, 0.9)', fill: false },
{ label: 'Open', data: dataOpen, borderColor: 'rgba(13, 110, 253, 0.7)', borderDash: [5, 5], fill: false },
{ label: 'Close', data: dataClose, borderColor: 'rgba(255, 193, 7, 0.7)', borderDash: [5, 5], fill: false }
]
},
options: {
responsive: true,
interaction: { mode: 'index', intersect: false },
plugins: { legend: { position: 'bottom' } },
scales: {
y: { title: { display: true, text: 'Rate (%)' } },
x: { title: { display: true, text: 'Period' } }
}
}
});
})();
</script>

For true candlestick rendering, you can transform this OHLC dataset into a financial charting library (e.g., a candlestick plugin for Chart.js) using the same fields returned by /ohlc.

Summarize trends with /fluctuation: period-over-period change stats

When analysts ask “How much did the cash rate move this year?” the /fluctuation endpoint provides a compact answer. It returns start-value, end-value, absolute change, percent change, and high/low across the range—perfect for headline metrics, alerts, and summary tiles in dashboards.

Endpoint: GET /api/v1/fluctuation

Required:

• start: YYYY-MM-DD
• end: YYYY-MM-DD
• symbols: comma-separated list

Example cURL:

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

Example JSON response:

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

Usage tips:

• Use change_pct for marketing summaries, and change for risk calculations that depend on absolute basis point moves.
• Combine with timeseries for richer context around the path taken between start and end (e.g., for volatility estimates).

Example Python (requests):

import requests

r = requests.get(
'https://interestratesapi.com/api/v1/fluctuation',
params=dict(start='2025-09-22', end='2026-09-22', symbols='RBA_CASH_RATE', api_key='YOUR_KEY')
)
print(r.json())

Example JavaScript (fetch):

const u = 'https://interestratesapi.com/api/v1/fluctuation?start=2025-09-22&end=2026-09-22&symbols=RBA_CASH_RATE&api_key=YOUR_KEY';
const resp = await fetch(u);
const out = await resp.json();
console.log(out);

Example PHP:

<?php
$u = 'https://interestratesapi.com/api/v1/fluctuation?start=2025-09-22&end=2026-09-22&symbols=RBA_CASH_RATE&api_key=YOUR_KEY';
$ch = curl_init($u);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$res = curl_exec($ch);
curl_close($ch);
echo $res;
?>

Check current conditions with /latest: dashboards and alerts

The /latest endpoint returns the most recent available value for each requested symbol, plus the date for each. It is an essential building block for:

• Real-time dashboards displaying current policy settings or interbank benchmarks.
• Alerting systems that notify stakeholders when the latest rate crosses thresholds.
• Comparative panels showing multiple markets side-by-side.

Endpoint: GET /api/v1/latest

Optional:

• symbols: comma-separated list (e.g., RBA_CASH_RATE,ECB_MRO)
• base: currency filter
• category: central_bank, interbank, treasury, reference

Example cURL:

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

Example JSON response:

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

Field notes:

• rates: the latest value for each symbol requested.
• dates: the date tied to each symbol’s latest observed value; always display alongside the numeric rate for transparency.
• base/currencies: helpful when joining rates with assets or liabilities denominated in specific currencies.

Example Python (requests):

import requests

res = requests.get(
'https://interestratesapi.com/api/v1/latest',
params=dict(symbols='RBA_CASH_RATE,ECB_MRO', api_key='YOUR_KEY')
)
print(res.json())

Example JavaScript (fetch):

const latestUrl = 'https://interestratesapi.com/api/v1/latest?symbols=RBA_CASH_RATE,ECB_MRO&api_key=YOUR_KEY';
const latestResp = await fetch(latestUrl);
const latestData = await latestResp.json();
console.log(latestData);

Example PHP:

<?php
$latest = 'https://interestratesapi.com/api/v1/latest?symbols=RBA_CASH_RATE,ECB_MRO&api_key=YOUR_KEY';
$ch = curl_init($latest);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$out = curl_exec($ch);
curl_close($ch);
echo $out;
?>

Compare borrowing costs with /convert: quick loan interest comparisons

For product managers and credit modelers, comparing borrowing costs at different benchmark rates can illuminate pricing strategy and risk. The /convert endpoint computes the total interest and total payment for a simple loan at the latest rate of two symbols. This is especially useful for scenario analysis or internal calculators that translate rate changes into dollar impacts.

Endpoint: GET /api/v1/convert

Required:

• from: symbol (e.g., RBA_CASH_RATE)
• to: symbol (e.g., ECB_MRO)
• amount: numeric greater than or equal to 0

Optional:

• term_months: 1–360 (default 12)

Example cURL:

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

Example JSON response:

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

Use cases:

• Communicating customer-facing impacts of central bank decisions.
• Internal risk reporting showing sensitivity of interest expense to different benchmarks.
• Sales enablement where relationship managers compare reference rates.

Example Python (requests):

import requests

c = requests.get(
'https://interestratesapi.com/api/v1/convert',
params=dict(from='RBA_CASH_RATE', to='ECB_MRO', amount=250000, term_months=24, api_key='YOUR_KEY')
)
print(c.json())

Example JavaScript (fetch):

const convUrl = 'https://interestratesapi.com/api/v1/convert?from=RBA_CASH_RATE&to=ECB_MRO&amount=250000&term_months=24&api_key=YOUR_KEY';
const convResp = await fetch(convUrl);
const convData = await convResp.json();
console.log(convData);

Example PHP:

<?php
$conv = 'https://interestratesapi.com/api/v1/convert?from=RBA_CASH_RATE&to=ECB_MRO&amount=250000&term_months=24&api_key=YOUR_KEY';
$ch = curl_init($conv);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$res = curl_exec($ch);
curl_close($ch);
echo $res;
?>

Production data pipeline in Python: fetch → pandas DataFrame → CSV/Parquet

Below is a concrete pipeline pattern that:

• Pulls multi-year RBA_CASH_RATE data via /timeseries.
• Normalizes it into a pandas DataFrame indexed by date.
• Exports both CSV and Parquet for downstream BI tools and data lakes.

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

API_BASE = 'https://interestratesapi.com/api/v1'
API_KEY = 'YOUR_KEY'

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

def to_dataframe(timeseries_json: dict, symbol: str) -> pd.DataFrame:
# Flatten nested rates -> {date: value}
series = timeseries_json['rates'].get(symbol, {})
# Convert to DataFrame with datetime index
df = pd.DataFrame(list(series.items()), columns=['date', symbol])
df['date'] = pd.to_datetime(df['date'])
df = df.sort_values('date').set_index('date')
return df

def add_metadata(df: pd.DataFrame, meta_json: dict, symbol: str) -> pd.DataFrame:
freq = meta_json.get('frequencies', {}).get(symbol, None)
curr = meta_json.get('currencies', {}).get(symbol, None)
df.attrs['symbol'] = symbol
df.attrs['frequency'] = freq
df.attrs['currency'] = curr
return df

def export_files(df: pd.DataFrame, out_dir: str, base_name: str):
os.makedirs(out_dir, exist_ok=True)
csv_path = os.path.join(out_dir, f'{base_name}.csv')
parquet_path = os.path.join(out_dir, f'{base_name}.parquet')
df.to_csv(csv_path, float_format='%.6f')
df.to_parquet(parquet_path, index=True)
print(f'Exported: {csv_path}, {parquet_path}')

if __name__ == '__main__':
symbol = 'RBA_CASH_RATE'
start = '2010-01-01'
end = datetime.utcnow().strftime('%Y-%m-%d')

data = fetch_timeseries(symbol, start, end)
df = to_dataframe(data, symbol)
df = add_metadata(df, data, symbol)

# Optional: Resample to month-end if desired (for reporting consistency)
# df_m = df.resample('M').last()

export_files(df, out_dir='exports', base_name=f'{symbol}_{start}_{end}')
print('Attributes:', df.attrs)

Notes:

• Resampling: If you want a strict month-end series (common for policy dashboards), resample to M and take last.
• Metadata: Store frequency and currency as DataFrame attributes for lineage documentation.
• Extensibility: Extend this pattern to multiple symbols (e.g., include JIBOR_3M alongside RBA_CASH_RATE) and write a join on the date index.

Time series pitfalls and how to address them

Working with interest rate time series often exposes subtle pitfalls that can skew analytics if left unaddressed:

• Mixed frequency confusion: Many central bank rates are monthly or event-driven, while interbank rates are daily. When merging series, explicitly align frequencies. For monthly rates, prefer month-end sampling and document assumptions.
• Missing dates: Interbank series do not print on weekends and some holidays. Downstream code should not assume a perfect daily sequence. Instead, use robust join operations that respect missing dates and avoid forward-filling unless it matches the business logic.
• data_points interpretation in OHLC: A low data_points count in a given month can reflect holidays, short months (February), or fewer trading days. Incorporate this into data quality dashboards to catch anomalies early.
• Point-in-time vs. revised data: For regulatory-grade backtests, preserve the returned dates with each rate to confirm the exact observation time used in a calculation.
• Comparability across benchmarks: Comparing JIBOR_3M to RBA_CASH_RATE is informative but conceptually different—one is an interbank offered rate term (money market benchmark), the other is a policy target rate. For pricing or risk models, ensure your interpretation aligns with the benchmark’s economic meaning.

By using a single source like interestratesapi.com for all categories—central bank, interbank, treasury, and reference—you reduce heterogeneity in schemas and error handling, which simplifies logic across ETL jobs and analytics layers. Explore the API here: Explore Interest Rates API features.

Complete endpoint coverage with practical examples

For quick reference, below are compact examples for each endpoint using cURL, Python, JavaScript, and PHP. Replace YOUR_KEY and adjust dates/symbols as needed.

/symbols

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

import requests
resp = requests.get('https://interestratesapi.com/api/v1/symbols',
params=dict(category='central_bank', base='AUD', api_key='YOUR_KEY'))
print(resp.json())

const resp = await fetch('https://interestratesapi.com/api/v1/symbols?category=central_bank&base=AUD&api_key=YOUR_KEY');
console.log(await resp.json());

<?php
$u = 'https://interestratesapi.com/api/v1/symbols?category=central_bank&base=AUD&api_key=YOUR_KEY';
$ch = curl_init($u);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$out = curl_exec($ch);
curl_close($ch);
echo $out;
?>

/latest

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

import requests
r = requests.get('https://interestratesapi.com/api/v1/latest',
params=dict(symbols='RBA_CASH_RATE,ECB_MRO', api_key='YOUR_KEY'))
print(r.json())

const r = await fetch('https://interestratesapi.com/api/v1/latest?symbols=RBA_CASH_RATE,ECB_MRO&api_key=YOUR_KEY');
console.log(await r.json());

<?php
$u = 'https://interestratesapi.com/api/v1/latest?symbols=RBA_CASH_RATE,ECB_MRO&api_key=YOUR_KEY';
$ch = curl_init($u);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
echo curl_exec($ch);
curl_close($ch);
?>

/historical

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

import requests
h = requests.get('https://interestratesapi.com/api/v1/historical',
params=dict(date='2025-06-15', symbols='RBA_CASH_RATE', api_key='YOUR_KEY'))
print(h.json())

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

<?php
$u = 'https://interestratesapi.com/api/v1/historical?date=2025-06-15&symbols=RBA_CASH_RATE&api_key=YOUR_KEY';
$ch = curl_init($u);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$out = curl_exec($ch);
curl_close($ch);
echo $out;
?>

/timeseries

curl "https://interestratesapi.com/api/v1/timeseries?start=2023-01-01&end=2026-09-22&symbols=RBA_CASH_RATE&api_key=YOUR_KEY"

import requests
t = requests.get('https://interestratesapi.com/api/v1/timeseries',
params=dict(start='2023-01-01', end='2026-09-22', symbols='RBA_CASH_RATE', api_key='YOUR_KEY'))
print(t.json())

const t = await fetch('https://interestratesapi.com/api/v1/timeseries?start=2023-01-01&end=2026-09-22&symbols=RBA_CASH_RATE&api_key=YOUR_KEY');
console.log(await t.json());

<?php
$u = 'https://interestratesapi.com/api/v1/timeseries?start=2023-01-01&end=2026-09-22&symbols=RBA_CASH_RATE&api_key=YOUR_KEY';
$ch = curl_init($u);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$out = curl_exec($ch);
curl_close($ch);
echo $out;
?>

/fluctuation

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

import requests
f = requests.get('https://interestratesapi.com/api/v1/fluctuation',
params=dict(start='2025-01-01', end='2026-09-22', symbols='RBA_CASH_RATE', api_key='YOUR_KEY'))
print(f.json())

const f = await fetch('https://interestratesapi.com/api/v1/fluctuation?start=2025-01-01&end=2026-09-22&symbols=RBA_CASH_RATE&api_key=YOUR_KEY');
console.log(await f.json());

<?php
$u = 'https://interestratesapi.com/api/v1/fluctuation?start=2025-01-01&end=2026-09-22&symbols=RBA_CASH_RATE&api_key=YOUR_KEY';
$ch = curl_init($u);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$out = curl_exec($ch);
curl_close($ch);
echo $out;
?>

/ohlc

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

import requests
o = requests.get('https://interestratesapi.com/api/v1/ohlc',
params=dict(symbols='RBA_CASH_RATE', period='monthly', start='2025-01-01', end='2026-09-22', api_key='YOUR_KEY'))
print(o.json())

const ohlcUrl = 'https://interestratesapi.com/api/v1/ohlc?symbols=RBA_CASH_RATE&period=monthly&start=2025-01-01&end=2026-09-22&api_key=YOUR_KEY';
const oResp = await fetch(ohlcUrl);
console.log(await oResp.json());

<?php
$u = 'https://interestratesapi.com/api/v1/ohlc?symbols=RBA_CASH_RATE&period=monthly&start=2025-01-01&end=2026-09-22&api_key=YOUR_KEY';
$ch = curl_init($u);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$out = curl_exec($ch);
curl_close($ch);
echo $out;
?>

/convert

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

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

const cvUrl = 'https://interestratesapi.com/api/v1/convert?from=RBA_CASH_RATE&to=ECB_MRO&amount=100000&term_months=12&api_key=YOUR_KEY';
const cvResp = await fetch(cvUrl);
console.log(await cvResp.json());

<?php
$u = 'https://interestratesapi.com/api/v1/convert?from=RBA_CASH_RATE&to=ECB_MRO&amount=100000&term_months=12&api_key=YOUR_KEY';
$ch = curl_init($u);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$out = curl_exec($ch);
curl_close($ch);
echo $out;
?>

Field-by-field breakdowns with realistic JSON examples

To ensure robust integration, always validate response fields and handle nulls prudently. Here are fully formed examples you can test against and mirror in unit tests.

Symbols example (mixed categories)

{
"success": true,
"count": 3,
"symbols": [
{
"symbol": "RBA_CASH_RATE",
"name": "Reserve Bank of Australia Cash Rate Target",
"category": "central_bank",
"country_code": "AU",
"currency_code": "AUD",
"frequency": "monthly",
"description": "Target cash rate set by the Reserve Bank of Australia"
},
{
"symbol": "JIBOR_3M",
"name": "Jakarta Interbank Offered Rate 3-Month",
"category": "interbank",
"country_code": "ID",
"currency_code": "IDR",
"frequency": "daily",
"description": "3-month Jakarta interbank offered rate"
},
{
"symbol": "US_TREASURY_10Y",
"name": "US Treasury 10-Year Yield",
"category": "treasury",
"country_code": "US",
"currency_code": "USD",
"frequency": "daily",
"description": "Constant maturity 10-year US Treasury yield"
}
]
}

Practical usage:

• Use category to segment UIs by rate family (central bank vs. interbank).
• Use frequency to choose rolling windows for volatility or to design aggregation rules.

Timeseries example (dual-symbol comparison)

{
"success": true,
"base": "MIXED",
"start_date": "2024-01-01",
"end_date": "2024-12-31",
"rates": {
"RBA_CASH_RATE": {
"2024-01-02": 4.35,
"2024-02-01": 4.35,
"2024-03-01": 4.35
},
"JIBOR_3M": {
"2024-01-02": 5.75,
"2024-01-03": 5.76,
"2024-01-04": 5.77
}
},
"frequencies": {
"RBA_CASH_RATE": "daily",
"JIBOR_3M": "daily"
},
"currencies": {
"RBA_CASH_RATE": "USD",
"JIBOR_3M": "IDR"
}
}

Implementation notes:

• Merge by date; expect many more rows for JIBOR_3M vs. RBA_CASH_RATE if the latter changes infrequently.
• For chart overlays, consider resampling JIBOR_3M to month-end average when comparing to a monthly policy rate.

OHLC example (quarterly)

{
"success": true,
"period": "quarterly",
"start_date": "2024-01-01",
"end_date": "2024-12-31",
"rates": {
"RBA_CASH_RATE": [
{ "period": "2024-Q1", "open": 4.35, "high": 4.35, "low": 4.35, "close": 4.35, "data_points": 61 },
{ "period": "2024-Q2", "open": 4.35, "high": 4.35, "low": 4.35, "close": 4.35, "data_points": 61 },
{ "period": "2024-Q3", "open": 4.35, "high": 4.60, "low": 4.35, "close": 4.60, "data_points": 64 },
{ "period": "2024-Q4", "open": 4.60, "high": 4.60, "low": 4.60, "close": 4.60, "data_points": 61 }
]
}
}

Interpretation:

• Stable quarters will yield identical open/high/low/close values; a rate move within the quarter will expand the high/low range.
• Use data_points to validate quarter completeness or to flag missing segments.

Fluctuation example (multi-symbol)

{
"success": true,
"rates": {
"RBA_CASH_RATE": {
"start_date": "2024-01-01",
"end_date": "2024-12-31",
"start_value": 4.35,
"end_value": 4.60,
"change": 0.25,
"change_pct": 5.75,
"high": 4.60,
"low": 4.35
},
"JIBOR_3M": {
"start_date": "2024-01-01",
"end_date": "2024-12-31",
"start_value": 5.75,
"end_value": 6.10,
"change": 0.35,
"change_pct": 6.09,
"high": 6.20,
"low": 5.70
}
}
}

This summary is ideal for executive scorecards or quick reports, complementing deep-dive analytics from timeseries windows.

Error handling and troubleshooting

Reliable financial data engineering must anticipate and handle error cases gracefully. interestratesapi.com returns a predictable error shape with success=false and a descriptive error message. You should:

• Validate input parameters (dates, symbols) before issuing requests where possible.
• Handle 404 cases where no data exists for a given symbol or range.
• Surface error messages in logs for faster debugging.
• Implement retries only when safe and appropriate for idempotent GET requests.

Common error structure:

{
"success": false,
"error": "No symbols matched"
}

Validation error example (422):

{
"success": false,
"error": "Validation error: invalid symbol 'RBA_CASH'",
"details": "Allowed symbols include: RBA_CASH_RATE, ..."
}

Missing data example (404):

{
"success": false,
"error": "No data for requested date/range",
"details": "RBA_CASH_RATE available from 1990-01-01 to 2026-09-22"
}

Troubleshooting tips:

• Check symbol spelling exactly as listed by /symbols (e.g., RBA_CASH_RATE, not RBA_RATE).
• Verify date formats are YYYY-MM-DD and the end date is not earlier than start.
• When fetching sparse monthly series, prefer month-end or use /historical with an in-month date to rely on last available mapping.

Design patterns and best practices for financial time series integration

To make your integration production-grade, consider:

• Immutable storage: Persist raw JSON responses for audit; maintain processed parquet files for analytics. The pipeline shown earlier can be extended to log raw payloads.
• Schema contracts: Build Pydantic (Python) or TypeScript interfaces that mirror expected fields (e.g., rates, frequencies, currencies) to catch upstream changes quickly.
• Caching and refresh cadence: Central bank policy rates typically update around meeting cycles; interbank benchmarks update daily. Align fetch schedules to typical update rhythms to reduce unnecessary calls while keeping data fresh.
• Idempotent retries: Since all endpoints are GET, safe retry patterns can be implemented where network faults occur.
• Unit tests: Create fixtures based on the JSON examples above and assert your parser handles mixed frequencies, missing dates, and different symbol sets.
• Visualization: For multi-metric dashboards, standardize axis scales (e.g., percent vs basis points) and label dates clearly using the dates field from /latest or explicit keys from /timeseries.

If you plan to compare central bank rates with interbank benchmarks (e.g., RBA_CASH_RATE vs. JIBOR_3M), define a harmonization step:

• Frequency alignment: Resample interbank to month-end average if you want comparability with monthly policy targets.
• Time zone considerations: If your downstream analytics annotate events by local dates, store country_code and currency_code for context in UI and audit logs.

For further exploration of features and capabilities, visit Explore Interest Rates API features and Get started with Interest Rates API.

From Jakarta Interbank Offered Rate 3-Month to RBA Cash Rate: applying identical patterns across markets

Although this tutorial demonstrates RBA_CASH_RATE in depth, your Jakarta Interbank Offered Rate 3-Month workflows follow the same blueprint. For example:

• Discovery: Use /symbols?category=interbank&base=IDR to confirm JIBOR_3M.
• Historical pulls: /timeseries for multi-year windows of JIBOR_3M for pre- and post-policy comparisons.
• Visuals: /ohlc to create candlesticks or band charts showing monthly high/low around significant macro events.
• Summaries: /fluctuation to quantify period deltas, communicate to stakeholders, and trigger alerts.

This consistency across rate families lets you reuse code modules (e.g., fetchers, validators, serializers) with different symbols, minimizing maintenance while maximizing coverage of global markets.

End-to-end example: cross-rate dashboard card (RBA_CASH_RATE vs JIBOR_3M)

Below is a compact front-end snippet that pulls latest values for both RBA_CASH_RATE and JIBOR_3M and renders a simple comparison block. Swap in your own UI framework as needed.

<div id="rateCard" style="font-family: sans-serif; max-width: 500px; border: 1px solid #ddd; padding: 12px;">
<h3>Policy vs Interbank Snapshot</h3>
<div id="content">Loading...</div>
</div>

<script>
(async function() {
const url = 'https://interestratesapi.com/api/v1/latest?symbols=RBA_CASH_RATE,JIBOR_3M&api_key=YOUR_KEY';
const r = await fetch(url);
const data = await r.json();
if (!data.success) {
document.getElementById('content').innerText = 'Error loading rates';
return;
}
const rba = data.rates['RBA_CASH_RATE'];
const jibor = data.rates['JIBOR_3M'];
const rbaDate = data.dates['RBA_CASH_RATE'];
const jiborDate = data.dates['JIBOR_3M'];

document.getElementById('content').innerHTML = `
<p><strong>RBA Cash Rate</strong>: ${rba}% &nbsp; <small>(${rbaDate})</small></p>
<p><strong>JIBOR 3M</strong>: ${jibor}% &nbsp; <small>(${jiborDate})</small></p>
`;
})();
</script>

By standardizing your UI cards on the /latest and /fluctuation endpoints and offering drill-downs via /timeseries and /ohlc, you can deliver a rich analytics experience with minimal code complexity.

Performance tips for robust analytics pipelines

While building larger systems:

• Batch symbols: If you are fetching multiple related series, request them together (symbols=a,b,c) instead of making separate calls; this simplifies joins and reduces overhead.
• Choose sensible windows: Use /timeseries windows aligned to your reporting cadence (e.g., last 5 years) and persist results for re-use in BI tools.
• Use OHLC selectively: Only fetch OHLC when building charts or analytics that require intra-period stats; otherwise stick with raw /timeseries for modeling.
• Validate completeness: Cross-check expected date counts or period ranges against data_points in OHLC and keys in timeseries to spot anomalies early.

For additional capabilities, examples, and concepts, visit Try Interest Rates API.

Conclusion: a single API for policy, interbank, and market reference rates

The most reliable fintech and research systems take historical interest rate data seriously—versioning, provenance, and reproducibility matter. interestratesapi.com provides the essential building blocks—discovery, latest snapshots, point-in-time retrievals, multi-year time series, computed OHLC, and fluctuation summaries—so you can focus on modeling, visualization, and product features.

Whether your immediate priority is Jakarta Interbank Offered Rate 3-Month for IDR liquidity insights or central bank policy analysis using RBA_CASH_RATE, the patterns above apply consistently: discover symbols with /symbols, fetch long windows with /timeseries, query precise dates with /historical, summarize moves with /fluctuation, render candlesticks with /ohlc, and translate rates to borrowing costs with /convert. Combine them into robust pipelines that write CSV and Parquet, and drive dashboards that communicate rate regimes clearly and credibly.

Build your next rate-powered product today: Try Interest Rates API, Explore Interest Rates API features, and Get started with Interest Rates API.