BOK (BOK_BASE_RATE) Rate Today

BOK (BOK_BASE_RATE) Rate Today

You need the Bank of Korea’s policy rate inside your application—accurately, with the correct effective date—so lenders can price loans, treasury teams can set transfer pricing, and analysts can chart policy cycles. By the end of this article, you will know how to fetch the BOK Base Rate (BOK_BASE_RATE) from the Interest Rates API, read the effective date, compare it to prior periods, compute spreads, drive a live React widget, and cache results safely in production.

What the BOK Base Rate means for your models

The BOK_BASE_RATE is the Bank of Korea’s main policy rate. It anchors the cost of won-denominated funding, influences retail lending and deposit rates, and is a key input when you model discount rates, liquidity stress tests, and loan pricing in KRW. The rate is expressed as an annualized percentage. For developers, the critical fields to read are the current value and the effective date, which determine how your systems roll forward to new pricing.

Illustration: BOK (BOK_BASE_RATE) Rate Today

All examples below use the Interest Rates API at interestratesapi.com. Requests are HTTP GET and authenticated with an api_key query parameter.

Fetch today’s BOK_BASE_RATE: endpoint, cURL, code, and fields

Use GET /api/v1/latest to retrieve the current rate and its effective date. The official cURL and JSON below are copy-pasteable and demonstrate the exact response shape for BOK_BASE_RATE.

Official cURL

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

Official JSON (verbatim)

{
    "success": true,
    "date": "2026-10-31",
    "base": "KRW",
    "rates": {
        "BOK_BASE_RATE": 3
    },
    "dates": {
        "BOK_BASE_RATE": "2026-10-31"
    },
    "currencies": {
        "BOK_BASE_RATE": "KRW"
    },
    "base_filter_note": null
}

How to read this response

  • rates.BOK_BASE_RATE: The policy rate as an annualized percentage.
  • dates.BOK_BASE_RATE: The effective date of the current rate in YYYY-MM-DD (use this to align pricing cutovers, not your local clock).
  • base and currencies.BOK_BASE_RATE: Currency code (KRW), helpful for filtering and downstream labeling.
  • date: The API’s response date context. For monthly policy rates, the effective date will match the most recent policy decision date available.

Tip: Persist both the value and dates.BOK_BASE_RATE to guarantee that you tie pricing decisions to the exact policy-effective date, especially around policy meetings and month-end boundaries.

Python: latest BOK_BASE_RATE

import requests

resp = requests.get(
'https://interestratesapi.com/api/v1/latest',
params=dict(symbols='BOK_BASE_RATE', api_key='YOUR_API_KEY')
)
data = resp.json()
rate = data['rates']['BOK_BASE_RATE']
effective_date = data['dates']['BOK_BASE_RATE']
currency = data['currencies']['BOK_BASE_RATE']

print(f"BOK_BASE_RATE: {rate}% (effective {effective_date}, currency {currency})")

JavaScript (fetch): latest BOK_BASE_RATE

const response = await fetch(
'https://interestratesapi.com/api/v1/latest?symbols=BOK_BASE_RATE&api_key=YOUR_API_KEY'
);
const data = await response.json();
const rate = data.rates.BOK_BASE_RATE;
const eff = data.dates.BOK_BASE_RATE;
console.log(`BOK_BASE_RATE: ${rate}% (effective ${eff})`);

PHP: latest BOK_BASE_RATE

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

$data = json_decode($res, true);
$rate = $data['rates']['BOK_BASE_RATE'];
$eff = $data['dates']['BOK_BASE_RATE'];

echo "BOK_BASE_RATE: {$rate}% (effective {$eff})\n";

Explore the API surface at Explore Interest Rates API features and MCP.

Publication rhythm, frequency, and effective dates

BOK_BASE_RATE is a central bank policy rate with monthly periodicity: policy decisions are typically scheduled monthly. The API will present daily granularity where relevant, but the value generally holds constant between policy changes. Always treat dates.BOK_BASE_RATE as the authoritative effective date.

  • Weekends/holidays: The value typically persists unchanged across non-business days until a new policy decision takes effect.
  • Caching: Cache by the pair (symbol, effective_date). You can cache aggressively intra-day and invalidate when dates.BOK_BASE_RATE changes.
  • Time zones: Dates are provided in YYYY-MM-DD without time zone offsets. Align to your application’s cutover logic using the effective date, not local-time midnight.

Try Interest Rates API to build a robust cache keyed on effective dates.

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

Use GET /api/v1/historical to retrieve the value on a specific date. For monthly symbols, the API uses “the last day with data within that month,” so specifying any date within a month returns the policy rate effective for that month.

cURL: 1 month ago and 1 year ago

(Replace the dates below with the anchors you need at runtime.)

Python: historical helper

import datetime as dt
import requests

api = "https://interestratesapi.com/api/v1/historical"
def get_bok_on(date_str):
r = requests.get(api, params=dict(date=date_str, symbols='BOK_BASE_RATE', api_key='YOUR_API_KEY'))
j = r.json()
return j['rates']['BOK_BASE_RATE'], j.get('date'), j['currencies']['BOK_BASE_RATE']

today = dt.date.today()
one_month_ago = (today.replace(day=1) - dt.timedelta(days=1)).strftime("%Y-%m-%d")
one_year_ago = today.replace(year=today.year - 1).strftime("%Y-%m-%d")

rate_m, _, _ = get_bok_on(one_month_ago)
rate_y, _, _ = get_bok_on(one_year_ago)
print(f"One month ago: {rate_m}% | One year ago: {rate_y}%")

JavaScript: historical

async function getBokOn(dateStr) {
const url = `https://interestratesapi.com/api/v1/historical?date=${dateStr}&symbols=BOK_BASE_RATE&api_key=YOUR_API_KEY`;
const res = await fetch(url);
const j = await res.json();
return j.rates.BOK_BASE_RATE;
}
// pick date boundaries in your app

PHP: historical

<?php
function bok_on($date) {
$url = "https://interestratesapi.com/api/v1/historical?date={$date}&symbols=BOK_BASE_RATE&api_key=YOUR_API_KEY";
$res = file_get_contents($url);
$j = json_decode($res, true);
return $j['rates']['BOK_BASE_RATE'];
}
// echo bok_on('2026-09-30');

Use these historical queries to compute deltas programmatically and annotate charts or loan repricing dashboards with “policy on date T.”

30-day change, pct, high, and low with /fluctuation

For a quick snapshot of movement over a period, the fluctuation endpoint returns start_value, end_value, absolute and percent change, plus high and low for the window.

cURL: 30-day window

Python: fluctuation

import requests
params = dict(start='2026-10-01', end='2026-10-31', symbols='BOK_BASE_RATE', api_key='YOUR_API_KEY')
fl = requests.get('https://interestratesapi.com/api/v1/fluctuation', params=params).json()
stats = fl['rates']['BOK_BASE_RATE']
print(stats['start_value'], stats['end_value'], stats['change'], stats['change_pct'], stats['high'], stats['low'])

JavaScript: fluctuation

const q = 'start=2026-10-01&end=2026-10-31&symbols=BOK_BASE_RATE&api_key=YOUR_API_KEY';
const f = await (await fetch('https://interestratesapi.com/api/v1/fluctuation?' + q)).json();
const s = f.rates.BOK_BASE_RATE;
console.log(s.start_value, s.end_value, s.change_pct);

PHP: fluctuation

<?php
$q = http_build_query([
'start' => '2026-10-01',
'end' => '2026-10-31',
'symbols' => 'BOK_BASE_RATE',
'api_key' => 'YOUR_API_KEY'
]);
$j = json_decode(file_get_contents('https://interestratesapi.com/api/v1/fluctuation?' . $q), true);
$stats = $j['rates']['BOK_BASE_RATE'];
echo "High: {$stats['high']} Low: {$stats['low']}\n";

These stats are useful for alerts and risk dashboards where you want both the level and its variability over your operating horizon.

Building a mini React widget that auto-refreshes

The snippet below polls GET /latest on an interval and renders the value plus effective date. For a production app, prefer exponential backoff and server-side caching to respect rate limits.

React component

import React from 'react';

export default function BokRateTile() {
const [rate, setRate] = React.useState(null);
const [eff, setEff] = React.useState(null);
const [err, setErr] = React.useState(null);

async function load() {
try {
const res = await fetch(
'https://interestratesapi.com/api/v1/latest?symbols=BOK_BASE_RATE&api_key=YOUR_API_KEY'
);
const j = await res.json();
if (!j.success) throw new Error(j.error || 'API error');
setRate(j.rates.BOK_BASE_RATE);
setEff(j.dates.BOK_BASE_RATE);
setErr(null);
} catch (e) {
setErr(String(e));
}
}

React.useEffect(() => {
load();
const id = setInterval(load, 60_000); // refresh every 60s; tune to your needs
return () => clearInterval(id);
}, []);

return (
<div style={{padding:12,border:'1px solid #ddd',borderRadius:6}}>
<div style={{fontSize:12, color:'#666'}}>BOK_BASE_RATE</div>
<div style={{fontSize:28, fontWeight:600}}>
{rate !== null ? `${rate}%` : '...'}
</div>
<div style={{fontSize:12, color:'#666'}}>
Effective: {eff || '...'}
</div>
{err && <div style={{color:'crimson', marginTop:8}}>{err}</div>}
</div>
);
}

For broader integration details, see Get started with Interest Rates API.

Time series and OHLC for charting

To draw charts or compute drawdowns, query a series between start and end with /timeseries. For candlestick views (e.g., monthly bars), use /ohlc, which is computed from daily data.

cURL: /timeseries

Python: /timeseries

import requests
ts = requests.get(
'https://interestratesapi.com/api/v1/timeseries',
params=dict(start='2025-11-17', end='2026-11-17', symbols='BOK_BASE_RATE', api_key='YOUR_API_KEY')
).json()
series = ts['rates']['BOK_BASE_RATE'] # dict of date -> value
# Plot or resample as needed

cURL: /ohlc (monthly bars)

JavaScript: /ohlc

const ohlcRes = await fetch(
'https://interestratesapi.com/api/v1/ohlc?symbols=BOK_BASE_RATE&period=monthly&start=2025-11-17&end=2026-11-17&api_key=YOUR_API_KEY'
);
const ohlc = await ohlcRes.json();
// ohlc.rates.BOK_BASE_RATE is an array of { period, open, high, low, close, data_points }

Spreads and loan math: using BOK_BASE_RATE inside pricing engines

Because the policy rate is an annualized percentage, computing spreads and payments is straightforward once you read the number and the effective date.

Spread between BOK_BASE_RATE and another benchmark

Example: spread to a 3M interbank rate like KORIBOR_3M. Fetch both with /latest and subtract.

import requests

def latest(symbol):
j = requests.get('https://interestratesapi.com/api/v1/latest',
params=dict(symbols=symbol, api_key='YOUR_API_KEY')).json()
return j['rates'][symbol], j['dates'][symbol]

bok, bok_eff = latest('BOK_BASE_RATE')
kori, kori_eff = latest('KORIBOR_3M')
spread = kori - bok
# Store the pair of effective dates; a production system may align to the max(eff) or a shared cutover policy.

Simple monthly payment from an annualized rate

Given principal P and annualized percentage r (e.g., the BOK_BASE_RATE value), convert to a monthly rate and use the annuity formula. Do not hardcode numbers; read from the API at runtime.

function monthlyPayment(principal, annualPct, termMonths) {
const m = (annualPct / 100) / 12; // monthly rate
if (m === 0) return principal / termMonths;
return principal * (m * Math.pow(1 + m, termMonths)) / (Math.pow(1 + m, termMonths) - 1);
}

// Example usage:
// const pmt = monthlyPayment(loanAmount, rateFromApi, months);

Because BOK_BASE_RATE is not a retail lending rate, most lenders add a margin and possibly a term-structure adjustment. Retrieve the policy rate, apply internal add-ons, and compute payments with the term-appropriate rate your product governance defines.

Operational considerations: reliability, caching, and limits

  • All endpoints are GET and authenticated with api_key. Avoid sending keys in headers; use the api_key query parameter.
  • Cache policy rates keyed by symbol and effective date. Bust cache only when dates.BOK_BASE_RATE changes—this minimizes traffic and ensures consistent pricing.
  • Rate limits: Honor Retry-After and X-RateLimit-* headers when present. Implement exponential backoff in crawlers or cron jobs.
  • Error handling: Check success == false and read error. Common statuses include 401 (key issues), 403 (access), 404 (no data for symbol/date), 422 (validation), 429 (quota). Surface operational logs with the query parameters you sent.
  • Idempotency: For the same symbol and effective date, the API value should be stable; treat values as immutable until a new policy date appears.

Discover symbols and filter by category or currency

Use /symbols to programmatically discover available identifiers and metadata across categories. BOK_BASE_RATE is in category=central_bank and currency KRW.

cURL: symbols

JavaScript: symbols

const s = await (await fetch('https://interestratesapi.com/api/v1/symbols?category=central_bank&base=KRW&api_key=YOUR_API_KEY')).json();
console.log(s.symbols.map(x => x.symbol));

Build your own allowlist from this catalogue and enforce it in client libraries to prevent typos from reaching production.

Why developers and traders track BOK_BASE_RATE daily

Even though policy changes are typically monthly, the value is a daily anchor in automated systems:

  • Pricing and margining: Treasury teams peg transfer pricing to the policy rate plus an internal spread that changes with liquidity conditions.
  • Risk and scenarios: Scenario engines shock the policy rate path and propagate to interbank rates and loan books.
  • Event detection: Systems watch for effective date changes to switch loan repricing regimes and update dashboards.

Tie these workflows to reliable effective dates via the API fields above. See Try Interest Rates API for additional examples and quick-starts.

Putting it all together

For production:

  • On app start, fetch /latest for BOK_BASE_RATE and store {value, effective_date}.
  • Schedule a light poll (e.g., hourly) or align to policy calendar. Persist when effective date changes.
  • Expose a health check that validates API success and the freshness of your cached effective date.
  • When comparing periods, use /historical to anchor 1M ago and 1Y ago, not ad hoc offsets that cross month-ends.
  • For analytics, use /fluctuation for quick stats and /timeseries or /ohlc for charting pipelines.

When you’re ready to build, Register and start integrating. You can also review the MCP to understand endpoints and fields at a glance.

FAQ

Q: What unit is BOK_BASE_RATE in, and how do I use it in calculations?
A: It’s an annualized percentage (e.g., “3” means 3% per annum). Convert to decimals by dividing by 100, and to monthly by dividing by 12 for simple annuity math. Always use the effective date to determine when to roll to a new rate.

Q: How frequently is the BOK_BASE_RATE updated in the API?
A: The rate reflects Bank of Korea policy decisions, typically monthly. The API exposes the most recent effective value on a daily basis; the value remains constant until a new decision is effective.

Q: Which date should my system store—response date or effective date?
A: Store dates.BOK_BASE_RATE as the authoritative effective date for pricing and backtesting. The top-level date is contextual, but the symbol-specific effective date governs when rate changes actually apply.

Q: Can I chart candles for a policy rate?
A: Yes. Use /ohlc with period=monthly (default) or weekly/quarterly. The endpoint computes OHLC from daily values, which will often produce flat candles between policy shifts.

Q: How should I cache results to limit API calls?
A: Cache by (symbol, effective_date). Invalidate only when dates.BOK_BASE_RATE changes. For historical, cache by (symbol, YYYY-MM) since monthly symbols use the last day with data for that month.

Build your BOK_BASE_RATE integration now: Try Interest Rates API, Explore Interest Rates API features, and Get started with Interest Rates API. When you’re ready to ship, Register and wire your api_key into the GET requests shown above.

Ready to get started?

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

Get API Key