API to Get the RBI (RBI_REPO_RATE) Rate

API to Get the RBI (RBI_REPO_RATE) Rate

You need the Reserve Bank of India’s policy rate in your software, fast and reliably. By the end of this guide, you will query RBI_REPO_RATE from the Interest Rates API, understand how to read its effective dates and frequency, and integrate it into dashboards, loan models, and risk engines using REST GET requests with api_key authentication.

What RBI_REPO_RATE Is and How It’s Expressed

RBI_REPO_RATE is the Reserve Bank of India Repo Rate, a central bank policy benchmark for INR. It is the rate at which the RBI lends short-term funds to commercial banks and is a core policy tool for managing liquidity and inflation. In the Interest Rates API, this symbol is categorized under central bank rates and provided as a percentage value (e.g., 5.25 means 5.25% annualized).

Illustration: API to Get the RBI (RBI_REPO_RATE) Rate

Frequency: monthly. While the RBI typically sets and maintains a policy rate between Monetary Policy Committee decisions, the API exposes the series at a monthly frequency. For monthly symbols, the historical endpoint returns the last date with available data within the requested month. The latest endpoint returns the most recent value and the effective date associated with it.

Effective dates: read the effective date for RBI_REPO_RATE from the dates map (when available) or from the date field in the response. Treat each returned rate as annualized percent. If you’re plugging RBI_REPO_RATE into a monthly interest calculation, divide by 12 for a simple nominal-rate approximation (see the calculation notes section below).

All requests use GET with the api_key query parameter. No headers for auth; do not use POST. Base URL for all requests: https://interestratesapi.com/api/v1/. See interestratesapi.com for product information and MCP for docs and schema details.

Authentication and Request Pattern

Every call uses GET and includes your key as a query string parameter: api_key=YOUR_API_KEY. Sample pattern:

  • Base: https://interestratesapi.com/api/v1/
  • Auth: ?api_key=YOUR_API_KEY
  • Endpoints: /symbols, /latest, /historical, /timeseries, /fluctuation, /ohlc, /convert

Example request composition: https://interestratesapi.com/api/v1/latest?symbols=RBI_REPO_RATE&api_key=YOUR_API_KEY

1) Catalogue of Available Symbols: /symbols

Use /symbols to discover available identifiers and filter for central bank rates or by currency. To find RBI_REPO_RATE specifically, filter by category and base currency (INR). The response includes name, category, country_code, currency_code, frequency, and a short description.

cURL

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

Python (requests)

import requests

resp = requests.get(
"https://interestratesapi.com/api/v1/symbols",
params=dict(category="central_bank", base="INR", api_key="YOUR_API_KEY"),
timeout=30
)
data = resp.json()
print(data.get("count"), "symbols found")
for s in data.get("symbols", []):
print(s["symbol"], s["name"], s["frequency"])

JavaScript (fetch)

const url = "https://interestratesapi.com/api/v1/symbols?category=central_bank&base=INR&api_key=YOUR_API_KEY";
const response = await fetch(url);
const data = await response.json();
console.log(data.count, "symbols");
(data.symbols || []).forEach(s => {
console.log(s.symbol, s.name, s.frequency);
});

PHP

<?php
$url = "https://interestratesapi.com/api/v1/symbols?category=central_bank&base=INR&api_key=YOUR_API_KEY";
$resp = file_get_contents($url);
$data = json_decode($resp, true);
echo $data["count"] . " symbols\n";
foreach (($data["symbols"] ?? []) as $s) {
echo $s["symbol"] . " " . $s["name"] . " " . $s["frequency"] . "\n";
}
?>

Example JSON (schema)

Illustrative schema from the documentation:

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

Interpretation: use symbol to query the rate (e.g., RBI_REPO_RATE), check frequency to plan caching, and use currency_code to confirm INR for RBI_REPO_RATE.

2) Latest RBI Repo Rate: /latest

Fetch the most recent RBI_REPO_RATE value with the official sample below. Values are annualized percent. Use the dates map to read the effective date of the current rate.

cURL (official sample)

JSON (official sample)

Key fields you will use:

  • rates.RBI_REPO_RATE: latest annualized percent
  • dates.RBI_REPO_RATE: effective date for the latest value
  • base and currencies maps: confirm currency context (INR)

Python (requests)

import requests

r = requests.get(
"https://interestratesapi.com/api/v1/latest",
params=dict(symbols="RBI_REPO_RATE", api_key="YOUR_API_KEY"),
timeout=30
)
j = r.json()
rate = j["rates"]["RBI_REPO_RATE"]
effective_date = j.get("dates", {}).get("RBI_REPO_RATE", j.get("date"))
print("RBI_REPO_RATE:", rate, "on", effective_date)

JavaScript (fetch)

const resp = await fetch(
"https://interestratesapi.com/api/v1/latest?symbols=RBI_REPO_RATE&api_key=YOUR_API_KEY"
);
const j = await resp.json();
const rate = j.rates.RBI_REPO_RATE;
const effectiveDate = (j.dates && j.dates.RBI_REPO_RATE) || j.date;
console.log("RBI_REPO_RATE:", rate, "on", effectiveDate);

PHP

<?php
$u = "https://interestratesapi.com/api/v1/latest?symbols=RBI_REPO_RATE&api_key=YOUR_API_KEY";
$j = json_decode(file_get_contents($u), true);
$rate = $j["rates"]["RBI_REPO_RATE"];
$effectiveDate = $j["dates"]["RBI_REPO_RATE"] ?? $j["date"];
echo "RBI_REPO_RATE: $rate on $effectiveDate\n";
?>

3) Value on a Specific Date: /historical

Get the RBI_REPO_RATE for a specific calendar date. For monthly symbols, the API uses the last date with data within that month if your date falls anywhere in the month.

cURL

JSON example

Notes:

  • For monthly series, the “date” echoes your request date; the value corresponds to the last day with data that month.
  • Use currencies map to confirm the unit context provided. Values are annualized percent.

Python (requests)

import requests

resp = requests.get(
"https://interestratesapi.com/api/v1/historical",
params=dict(date="2025-06-15", symbols="RBI_REPO_RATE", api_key="YOUR_API_KEY"),
timeout=30
)
hist = resp.json()
print(hist["date"], hist["rates"]["RBI_REPO_RATE"])

JavaScript (fetch)

const hurl = "https://interestratesapi.com/api/v1/historical?date=2025-06-15&symbols=RBI_REPO_RATE&api_key=YOUR_API_KEY";
const hresp = await fetch(hurl);
const h = await hresp.json();
console.log(h.date, h.rates.RBI_REPO_RATE);

PHP

<?php
$hurl = "https://interestratesapi.com/api/v1/historical?date=2025-06-15&symbols=RBI_REPO_RATE&api_key=YOUR_API_KEY";
$h = json_decode(file_get_contents($hurl), true);
echo $h["date"] . " " . $h["rates"]["RBI_REPO_RATE"] . "\n";
?>

4) Time Series: /timeseries

Query RBI_REPO_RATE between two dates to power charts and models. For monthly frequency, you’ll typically receive one value per effective period; some responses may normalize to daily keys containing repeated values over the effective window.

cURL

JSON example

Field notes:

  • rates map: nested date-to-value dictionary keyed by symbol.
  • frequencies map: the reported frequency used to generate the series in the response window.
  • currencies map: unit context.

Python (requests)

import requests

ts = requests.get(
"https://interestratesapi.com/api/v1/timeseries",
params=dict(start="2025-10-17", end="2026-10-17", symbols="RBI_REPO_RATE", api_key="YOUR_API_KEY"),
timeout=60
).json()

series = ts["rates"]["RBI_REPO_RATE"]
ordered = sorted(series.items()) # list of (date, value)
print("Points:", len(ordered))
print("First:", ordered[0])
print("Last:", ordered[-1])

JavaScript (fetch)

const tsUrl = "https://interestratesapi.com/api/v1/timeseries?start=2025-10-17&end=2026-10-17&symbols=RBI_REPO_RATE&api_key=YOUR_API_KEY";
const tsResp = await fetch(tsUrl);
const tsData = await tsResp.json();
const rows = Object.entries(tsData.rates.RBI_REPO_RATE).sort(([d1], [d2]) => d1.localeCompare(d2));
console.log("Observations:", rows.length);
console.log("First row:", rows[0]);

PHP

<?php
$tsUrl = "https://interestratesapi.com/api/v1/timeseries?start=2025-10-17&end=2026-10-17&symbols=RBI_REPO_RATE&api_key=YOUR_API_KEY";
$ts = json_decode(file_get_contents($tsUrl), true);
$series = $ts["rates"]["RBI_REPO_RATE"] ?? [];
ksort($series);
echo "Observations: " . count($series) . "\n";
reset($series);
echo "First: " . key($series) . " " . current($series) . "\n";
?>

5) Fluctuation Stats: /fluctuation

Compute start-to-end change, percentage change, and range (high/low) for RBI_REPO_RATE over a period. Useful for trend snapshots in dashboards or alerts.

cURL

JSON example

Key fields: start_value, end_value, absolute change, change_pct (null if start_value is 0), and the observed high/low over the window.

Python (requests)

import requests

fx = requests.get(
"https://interestratesapi.com/api/v1/fluctuation",
params=dict(start="2025-10-17", end="2026-10-17", symbols="RBI_REPO_RATE", api_key="YOUR_API_KEY"),
timeout=30
).json()
stats = fx["rates"]["RBI_REPO_RATE"]
print("Δ", stats["change"], "(", stats["change_pct"], "% )", "High:", stats["high"], "Low:", stats["low"])

JavaScript (fetch)

const fxUrl = "https://interestratesapi.com/api/v1/fluctuation?start=2025-10-17&end=2026-10-17&symbols=RBI_REPO_RATE&api_key=YOUR_API_KEY";
const fxResp = await fetch(fxUrl);
const fxData = await fxResp.json();
const s = fxData.rates.RBI_REPO_RATE;
console.log(`Change ${s.change} (${s.change_pct}%)`, "Range", s.low, "-", s.high);

PHP

<?php
$fxUrl = "https://interestratesapi.com/api/v1/fluctuation?start=2025-10-17&end=2026-10-17&symbols=RBI_REPO_RATE&api_key=YOUR_API_KEY";
$fx = json_decode(file_get_contents($fxUrl), true);
$s = $fx["rates"]["RBI_REPO_RATE"];
echo "Change {$s["change"]} ({$s["change_pct"]}%), High {$s["high"]}, Low {$s["low"]}\n";
?>

6) OHLC Candlesticks: /ohlc

Generate OHLC for RBI_REPO_RATE across weekly, monthly, or quarterly periods based on the underlying series. This is useful to compress timelines in charting.

cURL

JSON example

Key fields: open/high/low/close for each period, and data_points (count of observations used in aggregation).

Python (requests)

import requests

ohlc = requests.get(
"https://interestratesapi.com/api/v1/ohlc",
params=dict(symbols="RBI_REPO_RATE", period="monthly", start="2025-10-17", end="2026-10-17", api_key="YOUR_API_KEY"),
timeout=30
).json()
bars = ohlc["rates"]["RBI_REPO_RATE"]
for b in bars:
print(b["period"], b["open"], b["high"], b["low"], b["close"], "n=", b["data_points"])

JavaScript (fetch)

const oUrl = "https://interestratesapi.com/api/v1/ohlc?symbols=RBI_REPO_RATE&period=monthly&start=2025-10-17&end=2026-10-17&api_key=YOUR_API_KEY";
const oResp = await fetch(oUrl);
const o = await oResp.json();
(o.rates.RBI_REPO_RATE || []).forEach(b => {
console.log(b.period, b.open, b.high, b.low, b.close, "n=", b.data_points);
});

PHP

<?php
$oUrl = "https://interestratesapi.com/api/v1/ohlc?symbols=RBI_REPO_RATE&period=monthly&start=2025-10-17&end=2026-10-17&api_key=YOUR_API_KEY";
$o = json_decode(file_get_contents($oUrl), true);
foreach (($o["rates"]["RBI_REPO_RATE"] ?? []) as $b) {
echo "{$b["period"]} O:{$b["open"]} H:{$b["high"]} L:{$b["low"]} C:{$b["close"]} n={$b["data_points"]}\n";
}
?>

7) Compare Interest Costs: /convert

Use /convert to compare the total interest cost of a simple loan priced at RBI_REPO_RATE versus another benchmark. This endpoint returns the latest rate for each symbol and a simple-interest calculation over a given term_months. This is a quick way to quantify spreads in cash terms.

cURL

JSON example

Field notes: “from” and “to” include each rate and its effective date; difference.rate_spread is the arithmetic difference (percentage points). All amounts reflect a simple-interest comparison, not amortized schedules.

Python (requests)

import requests

cv = 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_API_KEY"),
timeout=30
).json()
print("Spread:", cv["difference"]["rate_spread"], "pp")
print("Interest saved:", cv["difference"]["interest_saved"])

JavaScript (fetch)

const cUrl = "https://interestratesapi.com/api/v1/convert?from=RBI_REPO_RATE&to=ECB_MRO&amount=100000&term_months=12&api_key=YOUR_API_KEY";
const cResp = await fetch(cUrl);
const c = await cResp.json();
console.log("Rate spread:", c.difference.rate_spread, "pp");

PHP

<?php
$cUrl = "https://interestratesapi.com/api/v1/convert?from=RBI_REPO_RATE&to=ECB_MRO&amount=100000&term_months=12&api_key=YOUR_API_KEY";
$c = json_decode(file_get_contents($cUrl), true);
echo "Spread: {$c["difference"]["rate_spread"]} pp; Interest saved: {$c["difference"]["interest_saved"]}\n";
?>

How to Read, Cache, and Use RBI_REPO_RATE in Apps

Units and rounding: Values are percentages (e.g., 5.25 means 5.25%). If presenting to end-users, you may keep two decimal places. For downstream models, store full precision returned by the API.

Effective dates and monthly cadence: The RBI_REPO_RATE series is monthly. For “point-in-time” logic, pair the numeric rate with its effective date from the dates map (latest endpoint) or determine the applicable month-end via /historical’s date behavior. For cross-month comparisons, prefer /fluctuation or /ohlc.

Business days and publication: Central bank decisions are not tied to market trading days. The API normalizes series to calendar dates with the documented frequency. When building alerts, check date changes rather than assuming a specific weekday cadence.

Caching strategy:

  • Latest endpoint: Cache for a day or until the next known policy decision window. In production, implement an etag of your own using the returned date and value.
  • Historical and timeseries: Cache aggressively per (symbol, date range) tuple. These data are immutable for past effective periods.
  • Fluctuation and OHLC: Consider caching at period granularity (e.g., month) because results depend on the requested range.

Error handling: Check success=false and read error messages. Use HTTP 429 headers (X-RateLimit-*) for retry pacing. Validate inputs to avoid 422 errors (e.g., start/end ordering and Y-m-d format). For 404 with details, adapt requested date windows to available ranges.

Security: Never expose YOUR_API_KEY in client-side apps; proxy via your backend for public UIs. All calls must be GET with the key in the query string per API design.

See interestratesapi.com for product overview and MCP for endpoint specifics.

Practical Calculations With RBI_REPO_RATE

Compute a spread

If you fetch RBI_REPO_RATE and another benchmark (e.g., an interbank rate), compute a simple spread as:

  • spread_pp = rate_A - rate_B (in percentage points)

Example usage in code: read both numbers from latest.rates and subtract. Use /convert for a quick check in cash terms for a simple-interest comparison.

Estimate a monthly payment (amortized loan)

RBI_REPO_RATE is annualized. To approximate a nominal monthly rate: r_m = r_annual / 12 / 100. For an amortizing loan with principal P and term n months, the standard formula is:

  • payment = P × r_m / (1 - (1 + r_m)^(-n))

Implementation notes:

  • Use the effective date to lock the rate for a given billing cycle.
  • If a product reprices monthly against RBI_REPO_RATE, recompute payment or interest for the next cycle using the value and date you retrieve near month-end.
  • Do not assume compounding method beyond your own product specs; the API provides the benchmark, not product rules.

Monthly accrual without amortization

For a simple monthly accrual: interest = principal × (r_annual / 12 / 100). This aligns with the simple-interest example returned by /convert; your actual product may apply different compounding or day-count conventions.

Common Integration Patterns and Use Cases

  • Fintech dashboards: Display the latest RBI_REPO_RATE with effective date, a last-12-month OHLC bar, and fluctuation summary (change_pct).
  • Loan repricing engines: Fetch /latest before repricing date, compute spread to an internal margin, and write the monthly rate to pricing records.
  • Treasury and ALM: Use /timeseries and /fluctuation to analyze policy cycles and sensitivity of asset yields to policy rate moves.
  • Macro research: Pull multi-year /timeseries for RBI_REPO_RATE to align with inflation, GDP, or credit growth series in your models.
  • Risk and stress: Apply scenario shocks to RBI_REPO_RATE by adjusting the returned value in simulations; persist original effective dates for audit trails.

Field Reference You’ll Actually Use

  • rates: mapping symbol → numeric value (percent)
  • dates: mapping symbol → effective date string (Y-m-d)
  • currencies: mapping symbol → currency code (e.g., INR)
  • frequencies: mapping symbol → frequency string (daily, monthly)
  • fluctuation fields: start_value, end_value, change, change_pct, high, low
  • ohlc fields: open, high, low, close, data_points per period

All sample values shown are illustrative from the documentation examples. Align your production logic to the numeric fields and ISO date strings returned by the API.

Operational Tips

  • Validate date ranges: end must be ≥ start. For monthly series, requesting granular daily windows will often return repeated values per effective window.
  • Missing data: A 404 with details can indicate out-of-range dates; adjust your window or check /symbols for each symbol’s availability.
  • Rate limits: Read X-RateLimit-Remaining and X-RateLimit-Reset and implement backoff on 429 with Retry-After.
  • Idempotence: All endpoints are GET; ensure your data pipeline handles retries safely.

FAQ

Q: What does RBI_REPO_RATE represent in this API?
A: It’s the Reserve Bank of India Repo Rate, expressed as an annualized percentage. Use the dates map or date field to read the effective date.

Q: How often is RBI_REPO_RATE updated?
A: It is exposed at monthly frequency. The effective rate changes when the RBI announces policy moves; values for the rest of the month typically reflect the prevailing policy setting.

Q: How should I store the data?
A: Persist symbol, value, effective date (from dates map), and currency. For time series, store the date-value pairs exactly as returned to avoid resampling errors.

Q: What if I need a cash-flow comparison using RBI_REPO_RATE?
A: Use /convert for a simple-interest comparison between RBI_REPO_RATE and another benchmark. For amortized loans, apply your own compounding and day-count rules using the latest rate as an input.

Q: How do I authenticate?
A: Append your key as a query parameter: ?api_key=YOUR_API_KEY. No auth headers, and only GET is supported.

Build your RBI_REPO_RATE integration now. Review the method catalog at the MCP, test the endpoints above, and then Register to get your API key. For additional context on the product and coverage, visit interestratesapi.com.

Keywords
API development RBI_REPO_RATE Interest Rates API Reserve Bank of India financial data integration

Ready to get started?

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

Get API Key