BSP (BSP_OVERNIGHT) Rate Today

BSP (BSP_OVERNIGHT) Rate Today

You're building a loan, treasury, or trading workflow that needs the current Bangko Sentral ng Pilipinas policy rate inside your app. By the end of this article, you’ll be able to query the BSP_OVERNIGHT rate with a single GET request, compare it with prior months, compute spreads and monthly payments programmatically, and wire a lightweight React dashboard that refreshes the live value from the Interest Rates API.

What BSP_OVERNIGHT represents and how it’s expressed

BSP_OVERNIGHT is the Bangko Sentral ng Pilipinas (BSP) Overnight Rate — the central bank’s key policy rate for the Philippine peso (PHP). In Interest Rates API responses, it is expressed as a percentage per annum (e.g., 5.50 means 5.50% annualized). This benchmark sets the policy stance affecting bank funding costs, lending rates, and short-term liquidity conditions in PHP markets.

Illustration: BSP (BSP_OVERNIGHT) Rate Today

Frequency: BSP_OVERNIGHT is published monthly. For monthly symbols, historical queries use the last day with data in that month if you specify an in-month date. When reading the API:

  • "date": The API processing date of your response (ISO Y-m-d).
  • "dates": Per-symbol effective date (ISO Y-m-d). For monthly benchmarks, this is typically the reference month’s final effective date.
  • "currencies": Confirms this symbol is in PHP for BSP_OVERNIGHT.

Developers and traders track BSP_OVERNIGHT because it anchors PHP funding costs, filters into consumer and mortgage lending benchmarks, and helps quantify monetary policy direction for risk models and balance sheet planning.

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

Fetch the BSP_OVERNIGHT rate (latest)

The latest endpoint returns the most recent value available for your symbols. For BSP_OVERNIGHT, you’ll receive a single numeric percentage and its effective date in "dates". Authentication uses the api_key query parameter; all endpoints are GET.

cURL (official sample)

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

Official JSON sample

{
    "success": true,
    "date": "2026-10-31",
    "base": "PHP",
    "rates": {
        "BSP_OVERNIGHT": 5.5
    },
    "dates": {
        "BSP_OVERNIGHT": "2026-10-31"
    },
    "currencies": {
        "BSP_OVERNIGHT": "PHP"
    },
    "base_filter_note": null
}

How to read it:

  • rates.BSP_OVERNIGHT is the percentage per annum (5.5 means 5.50%).
  • dates.BSP_OVERNIGHT is the effective date of this rate for the BSP_OVERNIGHT symbol.
  • base/currencies indicate PHP for the policy rate context.

Python (requests)

import requests

resp = requests.get(
"https://interestratesapi.com/api/v1/latest",
params=dict(symbols="BSP_OVERNIGHT", api_key="YOUR_API_KEY")
)
data = resp.json()
rate = data["rates"]["BSP_OVERNIGHT"]
effective_date = data["dates"]["BSP_OVERNIGHT"]
print("BSP_OVERNIGHT:", rate, "effective on", effective_date)

JavaScript (fetch)

const response = await fetch(
'https://interestratesapi.com/api/v1/latest?symbols=BSP_OVERNIGHT&api_key=YOUR_API_KEY'
);
const data = await response.json();
const rate = data.rates.BSP_OVERNIGHT;
const effectiveDate = data.dates.BSP_OVERNIGHT;
console.log('BSP_OVERNIGHT', rate, 'effective on', effectiveDate);

PHP

<?php
$url = 'https://interestratesapi.com/api/v1/latest?symbols=BSP_OVERNIGHT&api_key=YOUR_API_KEY';
$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$json = curl_exec($ch);
curl_close($ch);

$data = json_decode($json, true);
$rate = $data['rates']['BSP_OVERNIGHT'];
$effectiveDate = $data['dates']['BSP_OVERNIGHT'];
echo "BSP_OVERNIGHT: {$rate}% effective on {$effectiveDate}\n";

Compare today vs. 1 month and 1 year ago with /historical

Use the historical endpoint to anchor comparisons for a given date. For monthly series like BSP_OVERNIGHT, if you ask for a date within a month, the API returns the last day with data in that month.

cURL

JSON (sample)

Notes:

  • The "date" in the response echoes your query date.
  • For monthly series, use the note “the last day with data within that month is used” to interpret the effective month.
  • Returned values and base may vary depending on data provider mapping; use currencies.BSP_OVERNIGHT and dates (from /latest) to interpret units and timing. Values shown in the sample are illustrative from the documentation.

Python

import datetime as dt
import requests

api = "https://interestratesapi.com/api/v1/historical"
one_month_ago = (dt.date.today().replace(day=1) - dt.timedelta(days=1)).replace(day=15)
one_year_ago = dt.date(today.year - 1, today.month, 15)

# 1 month ago
m_resp = requests.get(api, params=dict(date=str(one_month_ago), symbols="BSP_OVERNIGHT", api_key="YOUR_API_KEY"))
m_data = m_resp.json()
m_value = m_data["rates"]["BSP_OVERNIGHT"]

# 1 year ago
y_resp = requests.get(api, params=dict(date=str(one_year_ago), symbols="BSP_OVERNIGHT", api_key="YOUR_API_KEY"))
y_data = y_resp.json()
y_value = y_data["rates"]["BSP_OVERNIGHT"]

print("BSP_OVERNIGHT 1m ago:", m_value)
print("BSP_OVERNIGHT 1y ago:", y_value)

JavaScript

function ymd(d){ return d.toISOString().slice(0,10); }

const now = new Date();
const d1 = new Date(now.getFullYear(), now.getMonth()-1, 15);
const d2 = new Date(now.getFullYear()-1, now.getMonth(), 15);

const mResp = await fetch(
`https://interestratesapi.com/api/v1/historical?date=${ymd(d1)}&symbols=BSP_OVERNIGHT&api_key=YOUR_API_KEY`
);
const mData = await mResp.json();

const yResp = await fetch(
`https://interestratesapi.com/api/v1/historical?date=${ymd(d2)}&symbols=BSP_OVERNIGHT&api_key=YOUR_API_KEY`
);
const yData = await yResp.json();

console.log("BSP_OVERNIGHT 1m ago:", mData.rates.BSP_OVERNIGHT);
console.log("BSP_OVERNIGHT 1y ago:", yData.rates.BSP_OVERNIGHT);

PHP

<?php
function fetchHistorical($date) {
$url = 'https://interestratesapi.com/api/v1/historical?date=' . $date .
'&symbols=BSP_OVERNIGHT&api_key=YOUR_API_KEY';
$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$json = curl_exec($ch);
curl_close($ch);
return json_decode($json, true);
}

$mData = fetchHistorical('2025-06-15');
$oneMonthValue = $mData['rates']['BSP_OVERNIGHT'];
echo "BSP_OVERNIGHT 1m ago: {$oneMonthValue}\n";

Quantify the last 30 days with /fluctuation

For a quick risk snapshot, the fluctuation endpoint summarizes change, percentage change, high, and low over a specified range. This is useful for dashboards and alerting when policy repricing is expected.

cURL

JSON (sample)

Python

import requests

resp = requests.get(
"https://interestratesapi.com/api/v1/fluctuation",
params=dict(start="2025-11-09", end="2026-11-09", symbols="BSP_OVERNIGHT", api_key="YOUR_API_KEY")
)
fx = resp.json()["rates"]["BSP_OVERNIGHT"]
print("Δ 30d:", fx["change"], "(", fx["change_pct"], "% ) high:", fx["high"], "low:", fx["low"])

JavaScript

const res = await fetch(
'https://interestratesapi.com/api/v1/fluctuation?start=2025-11-09&end=2026-11-09&symbols=BSP_OVERNIGHT&api_key=YOUR_API_KEY'
);
const fx = (await res.json()).rates.BSP_OVERNIGHT;
console.log(`Change: ${fx.change} (${fx.change_pct}%) High: ${fx.high} Low: ${fx.low}`);

PHP

<?php
$url = 'https://interestratesapi.com/api/v1/fluctuation?start=2025-11-09&end=2026-11-09&symbols=BSP_OVERNIGHT&api_key=YOUR_API_KEY';
$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$json = curl_exec($ch);
curl_close($ch);
$fx = json_decode($json, true)['rates']['BSP_OVERNIGHT'];
echo "Change: {$fx['change']} ({$fx['change_pct']}%) High: {$fx['high']} Low: {$fx['low']}\n";

Build a minimal React widget to display and refresh BSP_OVERNIGHT

This component fetches the latest BSP_OVERNIGHT and refreshes at a safe interval (e.g., every few hours for a monthly rate). Adjust the interval for your operational needs and rate limits.

import React, { useEffect, useState } from 'react';

export default function BspOvernightTile() {
const [rate, setRate] = useState(null);
const [asOf, setAsOf] = useState(null);
const [loading, setLoading] = useState(true);
const [err, setErr] = useState(null);

async function load() {
try {
setLoading(true);
const resp = await fetch(
'https://interestratesapi.com/api/v1/latest?symbols=BSP_OVERNIGHT&api_key=YOUR_API_KEY'
);
const data = await resp.json();
if (!data.success) throw new Error(data.error || 'API error');
setRate(data.rates.BSP_OVERNIGHT);
setAsOf(data.dates.BSP_OVERNIGHT);
setErr(null);
} catch (e) {
setErr(e.message);
} finally {
setLoading(false);
}
}

useEffect(() => {
load();
const id = setInterval(load, 1000 * 60 * 60 * 6); // refresh every 6h
return () => clearInterval(id);
}, []);

if (loading) return <div>Loading BSP_OVERNIGHT...</div>;
if (err) return <div>Error: {err}</div>;
return (
<div role="region" aria-label="BSP Overnight Rate">
<div>BSP_OVERNIGHT: <strong>{rate}%</strong></div>
<div>Effective date: {asOf}</div>
</div>
);
}

Compute spreads and monthly payments from BSP_OVERNIGHT

Two common tasks are to compute a spread over another benchmark and to translate an annual percentage rate into a monthly payment for a fixed-principal or amortizing loan. You can do this client-side with values returned by /latest, or use /convert for a quick total-interest comparison.

  • Rate spread: spread = rateA - rateB. Example in code: spread = data.rates.BSP_OVERNIGHT - otherRate.
  • Monthly payment (amortizing): M = P * r_m / (1 - (1 + r_m)^(-n)), where r_m = (annual_rate / 100) / 12, n = term months.
  • Simple-interest estimate for short-term loans: interest = P * (annual_rate / 100) * (term_months/12).

To compare loan interest costs between two symbols at the latest values, use /convert:

cURL

JSON (sample)

The response includes each rate’s latest value and a simple-interest cost comparison for the specified principal and term.

Why BSP_OVERNIGHT moves — and why to track it

Central bank decisions on BSP_OVERNIGHT reflect inflation expectations, output gaps, exchange-rate dynamics, and financial stability considerations. For developers, this rate informs pricing logic (e.g., mortgages or corporate loans indexed to policy), funding and treasury forecasts, and stress test scenarios.

  • Developers: build conditional pricing (e.g., loan APR = BSP_OVERNIGHT + margin) and refresh monthly.
  • Analysts: watch month-over-month change with /fluctuation to track policy shifts.
  • Treasury: align cash forecasts and hedging based on likely path of policy rates.

Explore complete endpoints and examples at interestratesapi.com, and MCP for key concepts.

Supporting endpoints: symbols, timeseries, and OHLC

To verify the symbol and its metadata, list central bank symbols or filter by currency:

cURL (/symbols)

Use /timeseries to retrieve time series between two dates for BSP_OVERNIGHT (useful for charts and backtests):

cURL (/timeseries)

JSON (sample)

For aggregated charting, /ohlc computes candlesticks on the fly from daily data. For monthly BSP_OVERNIGHT, this helps visualize open-high-low-close by month.

cURL (/ohlc)

JSON (sample)

Operational details that save time

  • HTTP method: All endpoints are GET. Do not use POST for data retrieval.
  • Authentication: Use api_key as a query parameter (e.g., ?api_key=YOUR_API_KEY). Do not send it in a header.
  • Frequency and business days: BSP_OVERNIGHT is monthly. For dashboards, polling daily is sufficient. For batch pipelines, refresh post-publication or monthly end-of-period. If you query dates without data, the service returns 404 or maps to the month’s last available date depending on endpoint rules.
  • Caching: Because BSP_OVERNIGHT is monthly, cache until the effective "dates" value changes. You can also use the 30-day /fluctuation snapshot to verify if a new month’s value has landed.
  • Error handling: Check success=false and error message. Be ready for 401/403 for auth issues, 404 for missing symbols or dates, 422 for validation errors, and 429 when quota is exhausted. Respect X-RateLimit-* and Retry-After headers.
  • Units and parsing: Rates are numeric percentages per annum. Store internally as decimals or basis points depending on your model, but display using percentage formatting.
  • Timezones and dates: Dates are ISO Y-m-d. For monthly series, rely on the “dates” map in /latest and the monthly fallback rule in /historical.

For more details and examples, visit interestratesapi.com. To start integrating BSP_OVERNIGHT in your app now, Register.

End-to-end example: load, compare, and compute a BSP-indexed monthly payment

The following sequence stitches together core operations you’ll do in production.

  1. Get the current BSP_OVERNIGHT with /latest. Extract rates.BSP_OVERNIGHT and dates.BSP_OVERNIGHT.
  2. Fetch 1 month ago with /historical (choose a mid-month date like the 15th). Extract the rate and compute Δ1m.
  3. Fetch /fluctuation for the last 30 days to populate a change badge and alerts.
  4. Compute an amortized monthly payment using your loan margin over BSP_OVERNIGHT:
    • r_annual = bsp + margin
    • r_m = (r_annual / 100) / 12
    • M = P * r_m / (1 - (1 + r_m)^(-n))

When you deploy, plug these steps into your backend job or client widget, refresher-scheduled according to monthly cadence and your SLA.

Troubleshooting and common pitfalls

  • Missing api_key: Returns 401. Ensure you append ?api_key=YOUR_API_KEY to every endpoint.
  • Using POST: All endpoints are GET. Switch to GET and pass params as query string or params object.
  • Invalid symbol: Returns 422 or 404. Confirm the symbol is exactly "BSP_OVERNIGHT". You can verify via /symbols.
  • Interpreting dates: For monthly series, /historical with any in-month date maps to the month’s last available date. Use "dates" in /latest to display the effective reference date.
  • Over-polling: BSP_OVERNIGHT updates monthly. Cache aggressively, and back off upon 429 with Retry-After.

FAQ

Q1: What currency is BSP_OVERNIGHT in?
A: PHP. The API confirms this in the "currencies" field for BSP_OVERNIGHT.

Q2: How often does BSP_OVERNIGHT update?
A: Monthly. For historical queries inside a month, the last day with data in that month is returned.

Q3: How do I compute a loan rate using BSP_OVERNIGHT?
A: Fetch the latest rate, add your margin (e.g., lender spread), and convert to a monthly rate for amortization: r_m = (annual_rate/100)/12, then compute the payment with standard amortization formula.

Q4: How do I compare BSP_OVERNIGHT to another central bank rate?
A: Use /latest with symbols=BSP_OVERNIGHT,OTHER_SYMBOL and compute the spread (rateA - rateB). For quick loan interest comparisons, use /convert.

Q5: What errors should I handle?
A: success=false with an "error" string; HTTP 401/403 for auth issues, 404 for missing data, 422 for invalid inputs, 429 for quota. Inspect X-RateLimit-* and Retry-After to schedule retries.

Ship your BSP_OVERNIGHT integration now. Read the docs at interestratesapi.com, review core concepts in MCP, and Register to get your API key and start testing today.

Ready to get started?

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

Get API Key