Historical RBI (RBI_REPO_RATE) Rates

Historical RBI (RBI_REPO_RATE) Rates

Teams building lending, treasury, and analytics apps often need reproducible, point-in-time history of the Reserve Bank of India’s policy rate to back-test pricing decisions and update dashboards. In this guide you will fetch and analyze historical RBI_REPO_RATE data, handle effective dates and frequency edge-cases, render charts, export data for pipelines, and compute spreads and payments using only the Interest Rates API endpoints.

What you will build with RBI_REPO_RATE

This article focuses exclusively on the Reserve Bank of India Repo Rate (symbol: RBI_REPO_RATE). You will learn to:

  • Retrieve multi-year time series with /timeseries for analysis and charting.
  • Query a point-in-time /historical value with correct monthly handling.
  • Summarize changes with /fluctuation and build OHLC candlesticks via /ohlc.
  • Create a Python data pipeline: fetch → pandas DataFrame → CSV/Parquet.
  • Compute simple spreads and monthly payments safely from the returned values.

All examples use GET requests to https://interestratesapi.com/api/v1/ with api_key as a query parameter. Authentication is always via the api_key parameter; no headers are used for authentication.

How RBI_REPO_RATE is represented in the API

RBI_REPO_RATE is a central bank policy rate for INR with monthly frequency. In the API it is returned as a numeric percentage value (for example 5.25), and dates represent the effective value for that calendar day. For monthly symbols, the API aligns values to the last day with data in a month when you query a specific date or build time series; this is important when your requested date falls on a weekend or holiday.

Interpretation tips for downstream uses:

  • The rate value is a percentage (e.g., 5.25 means 5.25%). When computing interest charges, convert to a decimal (rate / 100) and apply the correct compounding convention for your product.
  • For monthly frequency, consecutive business days in a month may repeat the same figure. Use monthly resampling or OHLC aggregation to avoid double counting.
  • If you show a “Last Updated” badge, prefer the date field returned alongside the rate for this symbol.

Start with the latest RBI_REPO_RATE

Below is the official latest RBI_REPO_RATE sample that you can copy-and-paste. It demonstrates the result shape you should expect when you ask for the symbol’s most recent value and effective date.

cURL

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

Sample JSON

{
    "success": true,
    "date": "2026-09-30",
    "base": "INR",
    "rates": {
        "RBI_REPO_RATE": 5.25
    },
    "dates": {
        "RBI_REPO_RATE": "2026-09-30"
    },
    "currencies": {
        "RBI_REPO_RATE": "INR"
    },
    "base_filter_note": null
}

Field notes:

  • rates.RBI_REPO_RATE: the policy rate as a percentage.
  • dates.RBI_REPO_RATE: the effective date for the latest value returned for this symbol.
  • base and currencies: the currency context; for RBI_REPO_RATE this is INR.

Use this endpoint to populate real-time dashboards or to set the base value before fetching historical series. See more capabilities and endpoints on Explore Interest Rates API features and Try Interest Rates API.

Fetching historical series with /timeseries (recommended for analytics)

The /timeseries endpoint returns values between a start and end date, making it ideal for multi-year back-tests and charting. For monthly symbols like RBI_REPO_RATE, you may see repeated daily rows with the same value inside a month because the symbol’s frequency is monthly. Use aggregation or resampling if you require one value per month.

cURL

JSON response shape

Notes on the shape and usage:

  • rates.RBI_REPO_RATE is a date → value mapping. For monthly symbols, multiple days within the same calendar month may share the same value.
  • frequencies helps you detect the granularity. You can downsample to monthly in your app if needed.
  • When computing changes month-over-month, aggregate by calendar month end or use /ohlc with period=monthly.

Python (requests) — fetch and iterate over the series

import requests

resp = requests.get(
'https://interestratesapi.com/api/v1/timeseries',
params=dict(
start='2025-11-16',
end='2026-11-16',
symbols='RBI_REPO_RATE',
api_key='YOUR_KEY'
),
timeout=30
)
data = resp.json()
series = data['rates']['RBI_REPO_RATE'] # dict of 'YYYY-MM-DD' -> value

# Example iteration
for d, v in sorted(series.items()):
# d is the effective date string, v is the percentage value
pass # plug into your analytics pipeline

JavaScript (fetch) — list dates and values

const url = 'https://interestratesapi.com/api/v1/timeseries?start=2025-11-16&end=2026-11-16&symbols=RBI_REPO_RATE&api_key=YOUR_KEY';
const response = await fetch(url);
const data = await response.json();
const series = data.rates['RBI_REPO_RATE']; // { 'YYYY-MM-DD': value }
for (const [date, value] of Object.entries(series)) {
// use date and value in your UI components
}

PHP — GET and parse

<?php
$endpoint = 'https://interestratesapi.com/api/v1/timeseries';
$query = http_build_query([
'start' => '2025-11-16',
'end' => '2026-11-16',
'symbols' => 'RBI_REPO_RATE',
'api_key' => 'YOUR_KEY'
]);
$resp = file_get_contents("$endpoint?$query");
$data = json_decode($resp, true);
$series = $data['rates']['RBI_REPO_RATE'];
foreach ($series as $date => $value) {
// process each date/value
}

/historical for specific effective-dates (monthly edge-cases)

Use /historical to retrieve the value on a single date. For monthly symbols, if you pick any date within a month, the API uses the last day with data in that month. This avoids gaps on weekends or holidays.

cURL

JSON response shape

Implementation tips:

  • Always display or log the date you requested alongside the effective policy rate, so auditors can re-run the same query later.
  • For UI date-pickers, you can use the middle of the month for simplicity; the API will resolve it to the effective month-end value for monthly symbols.

Python (requests)

import requests

r = requests.get(
'https://interestratesapi.com/api/v1/historical',
params=dict(date='2025-06-15', symbols='RBI_REPO_RATE', api_key='YOUR_KEY'),
timeout=15
)
payload = r.json()
value = payload['rates']['RBI_REPO_RATE']
effective = payload.get('date') # your requested date; the symbol value reflects the month’s effective figure

JavaScript (fetch)

const response = await fetch('https://interestratesapi.com/api/v1/historical?date=2025-06-15&symbols=RBI_REPO_RATE&api_key=YOUR_KEY');
const hist = await response.json();
const value = hist.rates['RBI_REPO_RATE'];

PHP

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

Summarize changes and volatility with /fluctuation

To quickly compute range statistics, use /fluctuation. It reports the start and end values, absolute and percentage change, and high/low over the range. Useful for risk dashboards and automated release notes.

cURL

JSON response shape

Python (requests)

import requests

res = requests.get(
'https://interestratesapi.com/api/v1/fluctuation',
params=dict(start='2025-11-16', end='2026-11-16', symbols='RBI_REPO_RATE', api_key='YOUR_KEY')
)
stats = res.json()['rates']['RBI_REPO_RATE']
# stats has start_value, end_value, change, change_pct, high, low

JavaScript (fetch)

const url = 'https://interestratesapi.com/api/v1/fluctuation?start=2025-11-16&end=2026-11-16&symbols=RBI_REPO_RATE&api_key=YOUR_KEY';
const stats = await (await fetch(url)).json();
const f = stats.rates['RBI_REPO_RATE'];

PHP

<?php
$resp = file_get_contents('https://interestratesapi.com/api/v1/fluctuation?start=2025-11-16&end=2026-11-16&symbols=RBI_REPO_RATE&api_key=YOUR_KEY');
$data = json_decode($resp, true);
$fl = $data['rates']['RBI_REPO_RATE'];

Build candlesticks for monthly charts with /ohlc

The /ohlc endpoint computes open, high, low, and close over rolling periods (monthly by default). This is an efficient way to transform daily series into one row per month suitable for candlestick charts. For RBI_REPO_RATE, OHLC quantifies within-month changes cleanly even if the rate only changes on certain decisions.

cURL

JSON response shape

About data_points: this is the count of underlying daily observations in the aggregation window. For monthly symbols, data_points reflects how many calendar days (with data) were included. Use it to validate completeness or to weight bars in custom analytics.

JavaScript + Chart.js snippet

The snippet below fetches OHLC data and prepares arrays you can plug into your candlestick chart. Replace the on-page chart rendering with your library’s candlestick adapter. If using Plotly, map the same open/high/low/close arrays to its candlestick trace.

async function loadOhlc() {
const url = 'https://interestratesapi.com/api/v1/ohlc?symbols=RBI_REPO_RATE&period=monthly&start=2025-11-16&end=2026-11-16&api_key=YOUR_KEY';
const res = await fetch(url);
const json = await res.json();
const rows = json.rates['RBI_REPO_RATE']; // array of { period, open, high, low, close }

const labels = rows.map(r => r.period); // 'YYYY-MM'
const open = rows.map(r => r.open);
const high = rows.map(r => r.high);
const low = rows.map(r => r.low);
const close= rows.map(r => r.close);

// Example with Chart.js Financial plugin (adapter omitted):
// new Chart(ctx, { type: 'candlestick', data: { datasets: [{ label: 'RBI_REPO_RATE', data: rows }] } });
}
loadOhlc();

Python data pipeline: fetch → pandas → CSV/Parquet

This end-to-end sample pulls a time series, normalizes it into a pandas DataFrame with one row per date, and writes both CSV and Parquet. It also demonstrates safe handling of missing dates and monthly consolidation.

Full Python example

import requests
import pandas as pd

API = 'https://interestratesapi.com/api/v1/timeseries'
params = dict(
start='2025-01-01',
end='2026-12-31',
symbols='RBI_REPO_RATE',
api_key='YOUR_KEY'
)

r = requests.get(API, params=params, timeout=60)
r.raise_for_status()
payload = r.json()
series = payload['rates']['RBI_REPO_RATE'] # dict: 'YYYY-MM-DD' -> value (percentage)

# Build DataFrame
df = pd.Series(series, name='rate_pct').rename_axis('date').reset_index()
df['date'] = pd.to_datetime(df['date'])
df = df.sort_values('date')

# Optional: consolidate to month-end (for monthly symbol)
monthly = (df
.set_index('date')
.resample('M')
.last()
.rename(columns={'rate_pct': 'rate_pct_month_end'})
.reset_index())

# Export artifacts
df.to_csv('rbi_repo_rate_daily.csv', index=False)
try:
# Requires pyarrow or fastparquet
monthly.to_parquet('rbi_repo_rate_monthly.parquet', index=False)
except Exception as e:
print('Parquet export skipped:', e)

print('Rows daily:', len(df), 'Rows monthly:', len(monthly))

Operational considerations:

  • Scheduling: run this job after the expected policy publication window for RBI. If you miss a month-end, the next run will backfill the correct month-end value.
  • Idempotency: use date-partitioned filenames or overwrite the same artifact; the series is deterministic for a given date.
  • Caching: cache the last N months in your store; for older ranges, keep snapshots. Respect rate limiting headers (X-RateLimit-*) and back off if you approach quotas.

Compute spreads and monthly payments

From any returned RBI_REPO_RATE value r_pct (percentage), convert to decimal r = r_pct / 100 for calculations. A few common computations:

  • Rate spread: spread = r_repo − r_other. To fetch both, you can call /latest with multiple symbols and subtract values. If you want an integrated simple-loan comparison, use /convert.
  • Simple interest over T months on amount A: interest = A × r × (T/12). For amortizing loans, compute the monthly rate i = r/12 and use the standard annuity formula.
  • Monthly payment for principal P, months n, annual rate r: payment = P × i × (1 + i)^n / ((1 + i)^n − 1), where i = r/12.

To compare loan interest cost using the latest rates, the /convert endpoint builds the calculation for you:

cURL

JSON response shape

You can also fetch both symbols via /latest and implement your own amortization logic. Keep the units straight: rates are percentages; convert to decimals before applying formulas.

Discovering symbols (catalog) and filtering

If you need to verify symbol availability or discover related benchmarks, use /symbols. You can filter by category (central_bank) and currency. RBI_REPO_RATE is a central bank symbol.

cURL

JSON response shape

Once you have the symbol you need, proceed with /latest, /historical, /timeseries, /fluctuation, or /ohlc as shown earlier. To get an API key and start testing requests, use Get started with Interest Rates API or Register.

Business-day behavior, publication frequency, and effective dates

RBI_REPO_RATE is monthly. In practice, that means:

  • Within a given calendar month, multiple days may carry the same policy rate value.
  • /historical requests for any date in a month map to the month’s effective rate on the last day with data.
  • /timeseries may present repeated daily rows; aggregate to month-end if you only want one row per month.

Effective dates returned in the API indicate the day on which the rate is effective in the dataset. Some months may have fewer observations if holidays fall at month-end; data_points in /ohlc clarifies coverage. If you need to align to business month-end for accounting, resample using your local business calendar or rely on /ohlc periodization.

Error handling, rate limits, and caching

Integrations should handle the documented error shapes and rate-limit headers to remain robust:

  • Errors return success=false with an error message. Common statuses: 401 (api_key issues), 403 (no active plan), 404 (no data for date/range), 422 (validation error), 429 (quota exhausted).
  • When you receive 429, honor Retry-After and check X-RateLimit-Limit, X-RateLimit-Remaining, and X-RateLimit-Reset headers before retrying.
  • Cache responses by date range. For immutable past months, cache aggressively. For the current month, refresh periodically until the month-end value is finalized.

See the machine-consumable reference at MCP for endpoint semantics, and Try Interest Rates API for more examples.

Complete reference examples per endpoint (RBI_REPO_RATE)

/latest

  • cURL: see the official sample earlier in this article.
import requests
response = requests.get(
'https://interestratesapi.com/api/v1/latest',
params=dict(symbols='RBI_REPO_RATE', api_key='YOUR_KEY')
)
data = response.json()
latest = data['rates']['RBI_REPO_RATE']
const response = await fetch(
'https://interestratesapi.com/api/v1/latest?symbols=RBI_REPO_RATE&api_key=YOUR_KEY'
);
const data = await response.json();
const latest = data.rates['RBI_REPO_RATE'];
<?php
$url = 'https://interestratesapi.com/api/v1/latest?symbols=RBI_REPO_RATE&api_key=YOUR_KEY';
$json = file_get_contents($url);
$data = json_decode($json, true);
$latest = $data['rates']['RBI_REPO_RATE'];

/historical

  • cURL: provided in the historical section.
import requests
response = requests.get(
'https://interestratesapi.com/api/v1/historical',
params=dict(date='2025-06-15', symbols='RBI_REPO_RATE', api_key='YOUR_KEY')
)
value = response.json()['rates']['RBI_REPO_RATE']
const r = await fetch('https://interestratesapi.com/api/v1/historical?date=2025-06-15&symbols=RBI_REPO_RATE&api_key=YOUR_KEY');
const hist = await r.json();
const value = hist.rates['RBI_REPO_RATE'];
<?php
$resp = file_get_contents('https://interestratesapi.com/api/v1/historical?date=2025-06-15&symbols=RBI_REPO_RATE&api_key=YOUR_KEY');
$val = json_decode($resp, true)['rates']['RBI_REPO_RATE'];

/timeseries

  • cURL: provided in the time series section.
import requests
response = requests.get(
'https://interestratesapi.com/api/v1/timeseries',
params=dict(start='2025-11-16', end='2026-11-16', symbols='RBI_REPO_RATE', api_key='YOUR_KEY')
)
series = response.json()['rates']['RBI_REPO_RATE']
const ts = await fetch('https://interestratesapi.com/api/v1/timeseries?start=2025-11-16&end=2026-11-16&symbols=RBI_REPO_RATE&api_key=YOUR_KEY').then(r => r.json());
const series = ts.rates['RBI_REPO_RATE'];
<?php
$ts = file_get_contents('https://interestratesapi.com/api/v1/timeseries?start=2025-11-16&end=2026-11-16&symbols=RBI_REPO_RATE&api_key=YOUR_KEY');
$series = json_decode($ts, true)['rates']['RBI_REPO_RATE'];

/fluctuation

  • cURL: provided in the fluctuation section.
import requests
summary = requests.get(
'https://interestratesapi.com/api/v1/fluctuation',
params=dict(start='2025-11-16', end='2026-11-16', symbols='RBI_REPO_RATE', api_key='YOUR_KEY')
).json()['rates']['RBI_REPO_RATE']
const fl = await fetch('https://interestratesapi.com/api/v1/fluctuation?start=2025-11-16&end=2026-11-16&symbols=RBI_REPO_RATE&api_key=YOUR_KEY').then(r => r.json());
const stats = fl.rates['RBI_REPO_RATE'];
<?php
$fl = file_get_contents('https://interestratesapi.com/api/v1/fluctuation?start=2025-11-16&end=2026-11-16&symbols=RBI_REPO_RATE&api_key=YOUR_KEY');
$stats = json_decode($fl, true)['rates']['RBI_REPO_RATE'];

/ohlc

  • cURL: provided in the OHLC section.
import requests
ohlc = requests.get(
'https://interestratesapi.com/api/v1/ohlc',
params=dict(symbols='RBI_REPO_RATE', period='monthly', start='2025-11-16', end='2026-11-16', api_key='YOUR_KEY')
).json()['rates']['RBI_REPO_RATE']
const o = await fetch('https://interestratesapi.com/api/v1/ohlc?symbols=RBI_REPO_RATE&period=monthly&start=2025-11-16&end=2026-11-16&api_key=YOUR_KEY').then(r => r.json());
const bars = o.rates['RBI_REPO_RATE'];
<?php
$o = file_get_contents('https://interestratesapi.com/api/v1/ohlc?symbols=RBI_REPO_RATE&period=monthly&start=2025-11-16&end=2026-11-16&api_key=YOUR_KEY');
$bars = json_decode($o, true)['rates']['RBI_REPO_RATE'];

/convert (optional spread/cost comparison)

  • cURL: provided in the convert section.
import requests
cmp = requests.get(
'https://interestratesapi.com/api/v1/convert',
params=dict(from='RBI_REPO_RATE', to='ECB_MRO', amount=100000, term_months=12, api_key='YOUR_KEY')
).json()
spread = cmp['difference']['rate_spread']
const cmp = await fetch('https://interestratesapi.com/api/v1/convert?from=RBI_REPO_RATE&to=ECB_MRO&amount=100000&term_months=12&api_key=YOUR_KEY').then(r => r.json());
const spread = cmp.difference.rate_spread;
<?php
$cmp = file_get_contents('https://interestratesapi.com/api/v1/convert?from=RBI_REPO_RATE&to=ECB_MRO&amount=100000&term_months=12&api_key=YOUR_KEY');
$data = json_decode($cmp, true);
$spread = $data['difference']['rate_spread'];

Time series pitfalls and how to avoid them

  • Missing dates: For monthly symbols, you may not get a row for every calendar day. If you require a continuous calendar index, forward-fill within each month after resampling.
  • Daily vs. monthly frequency: Don’t compute daily volatility on a monthly series. Use /ohlc or resample to one row per month for proper month-over-month changes.
  • data_points in /ohlc: Use it to flag incomplete months during partial periods; avoid drawing a full-height candlestick if data_points is unexpectedly small.
  • Date boundaries: Always validate start ≤ end and trim ranges to your analytics window; a smaller window reduces payloads and speeds up processing.
  • Caching: Cache immutable historical months. For the current month, set shorter TTLs and extend TTL after the month closes.

If you need an end-to-end tutorial or a quick testbed, head to Explore Interest Rates API features and Try Interest Rates API.

FAQ

Q1: What timezone are dates returned in?
A: Dates are provided as ISO date strings (YYYY-MM-DD). Treat them as calendar dates without assuming an intraday timestamp. Align to your system’s timezone only for UI display; do not shift dates.

Q2: How often does RBI_REPO_RATE update?
A: RBI_REPO_RATE is monthly in this API. Within a month, it can remain unchanged across multiple days. Use /timeseries or /ohlc to analyze month-over-month changes, and /latest for the current effective value and date.

Q3: How do I handle weekends and holidays for /historical?
A: For monthly symbols, any date within the month resolves to the last day with data in that month. You don’t need to pre-adjust dates that fall on weekends or holidays.

Q4: Can I compare RBI_REPO_RATE to another benchmark?
A: Yes. Use /latest with multiple symbols to compute a spread, or /convert to compare simple-loan total interest between RBI_REPO_RATE and another central bank rate.

Q5: What should I do if I hit a 429 rate limit?
A: Respect Retry-After and inspect X-RateLimit-Limit, X-RateLimit-Remaining, and X-RateLimit-Reset headers to schedule retries. Add client-side caching for stable historical ranges.

Build on this: register and ship your integration

You now have everything to fetch, store, chart, and compute with historical RBI_REPO_RATE data using the Interest Rates API. Create an API key and start testing within minutes: Register. For endpoint references and machine-consumable metadata, see MCP. Also, explore the platform and examples here: Try Interest Rates API, Explore Interest Rates API features, and Get started with Interest Rates API.

Ready to get started?

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

Get API Key