Norges Bank (NORGES_SIGHT_DEPOSIT) Rate Today

Norges Bank (NORGES_SIGHT_DEPOSIT) Rate Today

You need the current Norges Bank policy rate inside your software and the ability to contrast it with recent history, compute spreads, and update dashboards without manual intervention. By the end of this article, you will fetch the latest Norges Bank Sight Deposit Rate (symbol NORGES_SIGHT_DEPOSIT) via the Interest Rates API, read its effective date and units correctly, compare it to prior periods, compute changes, and wire it into a production-ready web dashboard.

What the NORGES_SIGHT_DEPOSIT rate represents and why it matters

NORGES_SIGHT_DEPOSIT is the Norges Bank Sight Deposit Rate, a central bank policy rate for Norway’s NOK funding environment. Developers, lenders, and treasury teams track it to price NOK-denominated loans, compute margin over policy, and model interest expense or income. Changes in NORGES_SIGHT_DEPOSIT signal monetary policy stance shifts that ripple into interbank curves, mortgage resets, and floating-rate loan coupons.

Illustration: Norges Bank (NORGES_SIGHT_DEPOSIT) Rate Today

Data for NORGES_SIGHT_DEPOSIT is retrieved from Try Interest Rates API, delivered as JSON over REST using GET requests with an api_key query parameter. This post focuses on using the /latest endpoint for real-time consumption and then extends to /historical and /fluctuation so you can build stable computations and visualizations. You can also Explore Interest Rates API features and Get started with Interest Rates API when you’re ready to integrate.

How to fetch today’s Norges Bank Sight Deposit Rate (NORGES_SIGHT_DEPOSIT)

The /latest endpoint returns the current rate with its effective date. All requests are GET, and authentication is via the api_key query parameter. Always use the base URL https://interestratesapi.com/api/v1/.

Official cURL (copy-paste)

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

Official JSON example

{
    "success": true,
    "date": "2026-10-31",
    "base": "NOK",
    "rates": {
        "NORGES_SIGHT_DEPOSIT": 4.5
    },
    "dates": {
        "NORGES_SIGHT_DEPOSIT": "2026-10-31"
    },
    "currencies": {
        "NORGES_SIGHT_DEPOSIT": "NOK"
    },
    "base_filter_note": null
}

How to read this:

  • rates.NORGES_SIGHT_DEPOSIT is the policy rate level, expressed in percent (e.g., 4.5 means 4.5% per annum).
  • dates.NORGES_SIGHT_DEPOSIT is the effective date for that symbol. For monthly symbols, this typically indicates the month-end or the last publication day in the month with data.
  • base and currencies.NORGES_SIGHT_DEPOSIT show the currency context (NOK for Norges Bank).

Python (requests)

import requests

url = "https://interestratesapi.com/api/v1/latest"
params = {
"symbols": "NORGES_SIGHT_DEPOSIT",
"api_key": "YOUR_API_KEY"
}
r = requests.get(url, params=params, timeout=10)
r.raise_for_status()
data = r.json()

rate = data["rates"]["NORGES_SIGHT_DEPOSIT"]
effective_date = data["dates"]["NORGES_SIGHT_DEPOSIT"]
currency = data["currencies"]["NORGES_SIGHT_DEPOSIT"]

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

JavaScript (fetch)

const res = await fetch(
"https://interestratesapi.com/api/v1/latest?symbols=NORGES_SIGHT_DEPOSIT&api_key=YOUR_API_KEY"
);
if (!res.ok) throw new Error(`HTTP ${res.status}`);
const data = await res.json();

const rate = data.rates.NORGES_SIGHT_DEPOSIT;
const effectiveDate = data.dates.NORGES_SIGHT_DEPOSIT;
const currency = data.currencies.NORGES_SIGHT_DEPOSIT;

console.log(`NORGES_SIGHT_DEPOSIT: ${rate}% (effective ${effectiveDate}, ${currency})`);

PHP (cURL)

<?php
$endpoint = "https://interestratesapi.com/api/v1/latest?symbols=NORGES_SIGHT_DEPOSIT&api_key=YOUR_API_KEY";
$ch = curl_init($endpoint);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$json = curl_exec($ch);
if ($json === false) {
throw new Exception("cURL error: " . curl_error($ch));
}
curl_close($ch);

$data = json_decode($json, true);
$rate = $data["rates"]["NORGES_SIGHT_DEPOSIT"];
$effectiveDate = $data["dates"]["NORGES_SIGHT_DEPOSIT"];
$currency = $data["currencies"]["NORGES_SIGHT_DEPOSIT"];

echo "NORGES_SIGHT_DEPOSIT: {$rate}% (effective {$effectiveDate}, {$currency})\n";

Publication cadence, business days, and effective dates

NORGES_SIGHT_DEPOSIT is a monthly central bank symbol. You should not expect a new value every business day; instead, the value reflects Norges Bank’s prevailing policy setting for that month. The effective date in the dates field is authoritative for downstream logic (e.g., accrual periods, rate cards, and dashboards).

Because the value changes infrequently, production systems often cache /latest responses. A pragmatic approach is to cache until you observe a new effective date for the symbol. If you are polling, consider a longer TTL intraday and a tighter schedule around anticipated policy meetings. For fail-safety, surface the effective date explicitly anywhere you display the rate.

Compare today’s rate to one month and one year ago

Use /historical to get the rate for specific dates and compare it with today’s /latest value. For monthly symbols, the API uses the last day with data in the month you request, so you can request mid-month dates and still get the month’s value.

cURL (one month ago and one year ago)

Replace the dates with ISO YYYY-MM-DD values for your comparison windows.

Historical JSON example

Notes:

  • The value is expressed as a percentage (e.g., 5.33 means 5.33% per annum).
  • For monthly symbols, the API aligns your date to the latest day with data in that month.

Python: computing spreads over time

import datetime as dt
import requests

API = "https://interestratesapi.com/api/v1"
KEY = "YOUR_API_KEY"

# Latest
latest = requests.get(f"{API}/latest", params={"symbols": "NORGES_SIGHT_DEPOSIT", "api_key": KEY}).json()
r_today = float(latest["rates"]["NORGES_SIGHT_DEPOSIT"])
d_today = latest["dates"]["NORGES_SIGHT_DEPOSIT"]

# One month ago (same day last month; adjust if needed)
one_month_ago = (dt.date.fromisoformat(d_today) - dt.timedelta(days=30)).isoformat()
h1 = requests.get(f"{API}/historical", params={"date": one_month_ago, "symbols": "NORGES_SIGHT_DEPOSIT", "api_key": KEY}).json()
r_1m = float(h1["rates"]["NORGES_SIGHT_DEPOSIT"])

# One year ago
one_year_ago = (dt.date.fromisoformat(d_today) - dt.timedelta(days=365)).isoformat()
h2 = requests.get(f"{API}/historical", params={"date": one_year_ago, "symbols": "NORGES_SIGHT_DEPOSIT", "api_key": KEY}).json()
r_1y = float(h2["rates"]["NORGES_SIGHT_DEPOSIT"])

spread_1m = r_today - r_1m
spread_1y = r_today - r_1y

print(f"Today: {r_today}% | 1M change: {spread_1m:+.2f}pp | 1Y change: {spread_1y:+.2f}pp")

30-day change, high, low with /fluctuation

To summarize the recent move, use /fluctuation with a 30-day window. The response provides start_value and end_value, absolute change and change_pct, and the high and low within the period.

cURL: last 30 days

Fluctuation JSON example

Interpretation:

  • change is in percentage points (end_value − start_value).
  • change_pct is the percent move relative to start_value.
  • high and low are the extremes within the window.

Embed a live NORGES_SIGHT_DEPOSIT widget in React

The snippet below fetches the rate and effective date, refreshes at a specified interval, and renders a simple card. It uses only GET and the api_key query parameter.

import React from "react";

function useLatestNorgesRate(apiKey, refreshMs = 60_000) {
const [state, setState] = React.useState({ rate: null, date: null, err: null, loading: true });

async function load() {
try {
const url = `https://interestratesapi.com/api/v1/latest?symbols=NORGES_SIGHT_DEPOSIT&api_key=${encodeURIComponent(apiKey)}`;
const res = await fetch(url, { cache: "no-store" });
if (!res.ok) throw new Error(`HTTP ${res.status}`);
const data = await res.json();
setState({
rate: data.rates?.NORGES_SIGHT_DEPOSIT ?? null,
date: data.dates?.NORGES_SIGHT_DEPOSIT ?? null,
err: null,
loading: false
});
} catch (e) {
setState(s => ({ ...s, err: e.message, loading: false }));
}
}

React.useEffect(() => {
load();
const t = setInterval(load, refreshMs);
return () => clearInterval(t);
}, [apiKey, refreshMs]);

return state;
}

export default function NorgesSightDepositCard({ apiKey }) {
const { rate, date, err, loading } = useLatestNorgesRate(apiKey);

return (
<div style={{ border: "1px solid #ccc", padding: 12, borderRadius: 6, fontFamily: "sans-serif" }}>
<div style={{ fontSize: 14, color: "#666" }}>NORGES_SIGHT_DEPOSIT (NOK)</div>
{loading ? (
<div>Loading…</div>
) : err ? (
<div style={{ color: "crimson" }}>{err}</div>
) : (
<>
<div style={{ fontSize: 28, fontWeight: 700 }}>{rate}%</div>
<div style={{ fontSize: 12, color: "#666" }}>Effective {date}</div>
</>
)}
</div>
);
}

Using the rate in financial calculations

Because the API returns the rate in percent per annum, convert to a decimal before computing monthly or daily accruals. For a simple spread, subtract two rates (in percent) to get a result in percentage points. For loan modeling, convert to a periodic rate and apply the formula you need.

Compute a spread over NORGES_SIGHT_DEPOSIT

// Given rates in percent:
const norges = 4.5; // e.g., from data.rates.NORGES_SIGHT_DEPOSIT
const margin = 1.25; // your product's fixed margin in percentage points
const all_in = norges + margin; // percentage per annum
console.log(`All-in rate: ${all_in}%`);

Compute a monthly payment using the fetched rate

Use the standard annuity formula, with periodic_rate = (rate_percent / 100) / 12 for monthly compounding.

function monthlyPayment(principal, annualRatePercent, months) {
const r = (annualRatePercent / 100) / 12;
if (r === 0) return principal / months;
return principal * (r * Math.pow(1 + r, months)) / (Math.pow(1 + r, months) - 1);
}

// Example: principal from your app's input; rate from the API:
const ratePercent = 4.5; // data.rates.NORGES_SIGHT_DEPOSIT
const pmt = monthlyPayment(1_000_000, ratePercent, 240); // 20 years
console.log(`Monthly payment: ${pmt.toFixed(2)}`);

Tip: surface the effective date next to your computed payment so users understand which policy setting it reflects.

Error handling, rate limits, and operational guidance

When integrating into production, handle common errors using the API’s standardized error shape. The response includes success=false and an error message. HTTP codes include 401 for missing/invalid api_key, 403 when the account has no active plan, 404 if no symbol matched or data is not available for the requested range, 422 for validation errors, and 429 when the quota is exhausted. Rate limiting headers include X-RateLimit-Limit, X-RateLimit-Remaining, and X-RateLimit-Reset; 429 responses may include Retry-After.

Operational tips:

  • Cache /latest responses and invalidate on a new dates value for NORGES_SIGHT_DEPOSIT.
  • For monthly symbols, it’s normal not to see daily updates. Use /historical and /fluctuation for period comparisons instead of assuming daily ticks.
  • On user-facing UIs, always show the effective date to prevent confusion between policy cadence and market-daily expectations.

Explore more details in the MCP reference and test endpoints directly at Try Interest Rates API.

Supplementary endpoints you may use alongside NORGES_SIGHT_DEPOSIT

While /latest is your primary source for today’s value, the following endpoints can improve analytics and reporting pipelines. All examples use only GET requests with the api_key parameter.

/symbols — discover available identifiers

Filter the catalogue by category or currency to list central bank series, including NORGES_SIGHT_DEPOSIT.

/historical — value for a date (recap)

See the official sample earlier. It returns the rate as a percent and aligns to the last data day within the month for monthly symbols.

/fluctuation — summarized change (recap)

See the JSON example above for change, change_pct, high, and low in your chosen window.

/ohlc — monthly candles for reporting

For charting dashboards, you can compute OHLC from daily values (the API does it on the fly). For monthly reporting blocks in slides or PDFs, this is often more legible than a raw line.

Production checklist for NORGES_SIGHT_DEPOSIT consumers

  • Endpoint and method: use GET against https://interestratesapi.com/api/v1/latest with symbols=NORGES_SIGHT_DEPOSIT and api_key=YOUR_API_KEY.
  • Units: percent per annum. Convert to decimals for calculations.
  • Effective date: read from dates.NORGES_SIGHT_DEPOSIT; display it in UIs and store it alongside the rate for auditability.
  • Cadence: monthly for this symbol; do not assume daily updates. Use /historical and /fluctuation for comparisons.
  • Caching: cache /latest and invalidate on effective date changes; set conservative retry logic for 429 responses using Retry-After and X-RateLimit-* headers.
  • Error handling: parse the JSON error shape; surface friendly messages while logging details.

Why the rate moves and how developers track it

Although NORGES_SIGHT_DEPOSIT is set by policy decisions, developers still monitor it daily in automated pipelines because commercial rates, loan pricing engines, and treasury dashboards need to reflect policy changes immediately. Economic releases, inflation paths, currency dynamics, and central bank communications can lead to policy adjustments. For systems that manage NOK exposures or NOK-linked loans, the primary requirement is correctness and timeliness: always fetch the latest, confirm the effective date, then downstream your calculations (spreads, accruals, payments) accordingly.

Quick side-by-side: get, compare, and compute

JavaScript: fetch, compute spread, and update UI

async function getNorgesRate() {
const url = "https://interestratesapi.com/api/v1/latest?symbols=NORGES_SIGHT_DEPOSIT&api_key=YOUR_API_KEY";
const res = await fetch(url);
if (!res.ok) throw new Error(`HTTP ${res.status}`);
return res.json();
}

(async () => {
const data = await getNorgesRate();
const policy = data.rates.NORGES_SIGHT_DEPOSIT; // percent
const eff = data.dates.NORGES_SIGHT_DEPOSIT;
const margin = 1.00; // pp
const allInPercent = policy + margin;

document.getElementById("norgesRate").textContent = `${policy}%`;
document.getElementById("norgesDate").textContent = eff;
document.getElementById("norgesAllIn").textContent = `${allInPercent}%`;
})();

Attach spans with IDs norgesRate, norgesDate, and norgesAllIn in your HTML to render these values.

Get your API key and ship your integration

Start integrating the live policy rate today. Use the official docs, copy the code, and deploy with confidence. Register to obtain your api_key and build with Try Interest Rates API. For detailed reference and endpoint behavior, see the MCP. You can also Get started with Interest Rates API and Explore Interest Rates API features.

FAQ

How often does NORGES_SIGHT_DEPOSIT update?
It is a monthly central bank rate. Check /latest and the dates field to confirm the current effective month and refresh after policy decisions.

What unit is the rate in, and how do I compute a monthly rate?
The value is a percent per annum. Convert to decimals for math. For monthly compounding, use periodic = (percent / 100) / 12.

Which date should I display to users?
Display dates.NORGES_SIGHT_DEPOSIT from the /latest response. For comparisons, request /historical with your target dates; the API aligns to the last day with data in that month for monthly symbols.

How do I summarize recent moves?
Use /fluctuation with start and end dates. Parse change, change_pct, high, and low to generate a 30-day or quarter-to-date summary.

How should I cache responses?
Cache /latest and invalidate when the effective date changes. For API reliability, handle 429 by respecting Retry-After and the X-RateLimit-* headers.

Ready to get started?

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

Get API Key