Need reliable, programmatic access to Norway’s sovereign bond yields for pricing models, dashboards, or macro research? This guide shows you exactly how to retrieve current, historical, intraday, and curve data for Norway (ISO2: NO) using the Bonds API over REST, then transform it into yield curves and spreads you can use immediately in your analytics and applications.
What You Can Build with Norway Sovereign Yields
With the Bonds API, you can:
- Pull the latest Norway yields across key maturities to power market monitors.
- Request a full yield curve to interpolate points for pricing and scenario analysis.
- Retrieve historical and intraday snapshots to backtest models and measure volatility.
- Compute spreads to benchmarks (e.g., vs US Treasuries) for cross-market relative value work.
- Summarize changes, minima, and maxima over any window to support risk and performance reporting.
All endpoints are HTTP GET under the same base URL and authenticate with an API key in the header. You can find more details and get an API key at bonds-api.com or use the quick-start links at the end of this article.
Key Concepts: Yields, Maturities, and Business-Day Behavior
Norway sovereign bond yields represent the annualized yield to maturity for government securities denominated in NOK across different tenors (e.g., 1M, 3M, 6M, 1Y, 2Y, 5Y, 10Y, 30Y). Yields returned by the API are expressed in percent (for example, 4.52 means 4.52%). Spreads are provided in basis points (bps), where 1 basis point = 0.01 percentage points.
Bonds trade on business days. When requesting historical dates that fall on weekends or market holidays, the API will return data for the specified date only if available; otherwise, it can return a “not found” error for that exact date. Time series endpoints will include business-day observations available within your requested range.
For caching, you can cache daily endpoints (latest, historical, curve, spread, fluctuation) within a trading day and refresh around your market data cutover. Intraday snapshots change throughout the day and should be cached with a shorter time-to-live if you need near-real-time updates.
Authentication, HTTP Method, and Base URL
- Base URL: https://bonds-api.com/api/v1/
- HTTP method: GET for all endpoints
- Authentication: X-API-Key header only (no query parameter for auth)
All examples below use X-API-Key: YOUR_API_KEY. Replace YOUR_API_KEY with your key from bonds-api.com.
Endpoint: Latest Yields for Norway
Use this to fetch the most recent available yields for specific maturities or all supported tenors for Norway (ISO2: NO). The example requests 2Y and 10Y.
cURL
curl -s "https://bonds-api.com/api/v1/latest?countries=US&maturities=10Y&api_key=YOUR_API_KEY"
Python (requests)
import requests
resp = requests.get(
"https://bonds-api.com/api/v1/latest",
headers={"X-API-Key": "YOUR_API_KEY"},
params={"countries": "NO", "maturities": "2Y,10Y"}
)
data = resp.json()
# Access Norway 2Y and 10Y yields (percent)
no_2y = data["data"]["NO"]["2Y"]["yield"]
no_10y = data["data"]["NO"]["10Y"]["yield"]
asof_date_2y = data["data"]["NO"]["2Y"]["date"] # YYYY-MM-DD
JavaScript (fetch)
const url = new URL("https://bonds-api.com/api/v1/latest");
url.searchParams.set("countries", "NO");
url.searchParams.set("maturities", "2Y,10Y");
fetch(url.toString(), {
method: "GET",
headers: { "X-API-Key": "YOUR_API_KEY" }
})
.then(r => r.json())
.then(json => {
const no2y = json.data.NO["2Y"].yield; // percent
const no10y = json.data.NO["10Y"].yield; // percent
const d = json.data.NO["10Y"].date; // "YYYY-MM-DD"
console.log({ no2y, no10y, d });
});
PHP (file_get_contents)
<?php
$context = stream_context_create([
"http" => [
"method" => "GET",
"header" => "X-API-Key: YOUR_API_KEY\r\n"
]
]);
$url = "https://bonds-api.com/api/v1/latest?countries=NO&maturities=2Y,10Y";
$json = file_get_contents($url, false, $context);
$data = json_decode($json, true);
$no10y = $data["data"]["NO"]["10Y"]["yield"]; // percent
$date = $data["data"]["NO"]["10Y"]["date"]; // YYYY-MM-DD
echo "NO 10Y: $no10y% on $date\n";
JSON response
{
"success": true,
"date": "2026-11-12",
"rates": {
"US_10Y": 4.998
},
"dates": {
"US_10Y": "2026-11-12"
},
"currencies": {
"US_10Y": "USD"
},
"meta": {
"request_id": "b4fd37a7-e96c-4891-bc37-955a3b5abed1",
"timestamp": "2026-11-12T00:06:22+00:00"
}
}
How to read it:
- yield: percentage value (e.g., 4.52 = 4.52%).
- date: YYYY-MM-DD as-of date for the latest observation.
- source: origin of the data point (e.g., “official”).
Endpoint: Historical Yield on a Specific Date
Fetch Norway’s yield for a single maturity on a specific date. This is ideal for T+N reporting, point-in-time backtests, or reproducing model results.
cURL
Python (requests)
import requests
params = {"country": "NO", "maturity": "10Y", "date": "2025-06-15"}
resp = requests.get(
"https://bonds-api.com/api/v1/historical",
headers={"X-API-Key": "YOUR_API_KEY"},
params=params
)
record = resp.json()
# record["yield"] is the point-in-time yield (percent)
no_10y = record["yield"]
point_date = record["date"]
JavaScript (fetch)
const url = new URL("https://bonds-api.com/api/v1/historical");
url.searchParams.set("country", "NO");
url.searchParams.set("maturity", "10Y");
url.searchParams.set("date", "2025-06-15");
fetch(url.toString(), { headers: { "X-API-Key": "YOUR_API_KEY" } })
.then(r => r.json())
.then(json => {
const y = json.yield; // percent
const d = json.date; // "YYYY-MM-DD"
console.log(`NO 10Y on ${d}: ${y}%`);
});
PHP (file_get_contents)
<?php
$q = http_build_query([
"country" => "NO",
"maturity" => "10Y",
"date" => "2025-06-15"
]);
$opts = ["http" => ["method" => "GET", "header" => "X-API-Key: YOUR_API_KEY\r\n"]];
$ctx = stream_context_create($opts);
$url = "https://bonds-api.com/api/v1/historical?$q";
$resp = file_get_contents($url, false, $ctx);
$data = json_decode($resp, true);
echo "Yield: {$data["yield"]}% as of {$data["date"]}\n";
JSON response
Field notes:
- yield: percentage (e.g., 4.38 = 4.38%).
- date: the requested date in YYYY-MM-DD format.
- source: data provenance.
Endpoint: Time Series Between Two Dates
Pull a continuous series for Norway across a window to chart trends, compute rolling stats, or drive factor models. The series will include available business-day observations between start and end (inclusive) in YYYY-MM-DD.
cURL
Python (requests)
import requests
import datetime as dt
params = {
"country": "NO",
"maturity": "10Y",
"start": "2025-11-12",
"end": "2026-11-12"
}
resp = requests.get(
"https://bonds-api.com/api/v1/timeseries",
headers={"X-API-Key": "YOUR_API_KEY"},
params=params
)
series = resp.json()["series"]
# series: list of {"date": "YYYY-MM-DD", "yield": float} (yield in percent)
dates = [pt["date"] for pt in series]
yields = [pt["yield"] for pt in series]
JavaScript (fetch)
const url = new URL("https://bonds-api.com/api/v1/timeseries");
url.searchParams.set("country", "NO");
url.searchParams.set("maturity", "10Y");
url.searchParams.set("start", "2025-11-12");
url.searchParams.set("end", "2026-11-12");
fetch(url.toString(), { headers: { "X-API-Key": "YOUR_API_KEY" } })
.then(r => r.json())
.then(json => {
// Each entry has { date: "YYYY-MM-DD", yield: number } with yield in percent
const series = json.series;
const last = series[series.length - 1];
console.log(`Observations: ${series.length}, last = ${last.date} : ${last.yield}%`);
});
PHP (file_get_contents)
<?php
$params = http_build_query([
"country" => "NO",
"maturity" => "10Y",
"start" => "2025-11-12",
"end" => "2026-11-12"
]);
$ctx = stream_context_create([
"http" => ["method" => "GET", "header" => "X-API-Key: YOUR_API_KEY\r\n"]
]);
$json = file_get_contents("https://bonds-api.com/api/v1/timeseries?$params", false, $ctx);
$data = json_decode($json, true);
$series = $data["series"];
JSON response
Note: yields are percent and dates are YYYY-MM-DD. Missing non-business days are not included.
Endpoint: Spread vs Benchmark
Compute Norway’s spread over a benchmark country at a chosen maturity (default 10Y). Spreads are returned in basis points (bps). This is useful for relative value, hedging, and cross-market monitoring.
cURL
Python (requests)
import requests
params = {"country": "NO", "benchmark": "US", "maturity": "10Y"}
resp = requests.get(
"https://bonds-api.com/api/v1/spread",
headers={"X-API-Key": "YOUR_API_KEY"},
params=params
)
s = resp.json()
spread_bps = s["spread_bps"] # integer/float, in basis points
country_yield = s["country_yield"] # percent
benchmark_yield = s["benchmark_yield"]
JavaScript (fetch)
const url = new URL("https://bonds-api.com/api/v1/spread");
url.searchParams.set("country", "NO");
url.searchParams.set("benchmark", "US");
url.searchParams.set("maturity", "10Y");
fetch(url.toString(), { headers: { "X-API-Key": "YOUR_API_KEY" } })
.then(r => r.json())
.then(json => {
// spread_bps is in basis points, yields are percent
console.log(`Spread: ${json.spread_bps} bps (NO ${json.country_yield}% vs ${json.benchmark_yield}%)`);
});
PHP (file_get_contents)
<?php
$q = http_build_query([
"country" => "NO",
"benchmark" => "US",
"maturity" => "10Y"
]);
$ctx = stream_context_create([
"http" => ["method" => "GET", "header" => "X-API-Key: YOUR_API_KEY\r\n"]
]);
$resp = file_get_contents("https://bonds-api.com/api/v1/spread?$q", false, $ctx);
$data = json_decode($resp, true);
printf("NO vs US 10Y spread: %d bps\n", $data["spread_bps"]);
JSON response
Field notes:
- spread_bps: basis points difference (NO minus benchmark).
- country_yield, benchmark_yield: yields in percent.
Endpoint: Full Yield Curve for Norway
Request the full set of available maturities for Norway for the latest available date or a specified date. This returns a cross-section you can use to build swap spreads, fit curves, or compute forward rates.
cURL
Python (requests)
import requests
resp = requests.get(
"https://bonds-api.com/api/v1/curve",
headers={"X-API-Key": "YOUR_API_KEY"},
params={"country": "NO"}
)
curve = resp.json()
asof = curve["date"] # YYYY-MM-DD
inverted = curve["inverted"] # boolean flag
points = curve["curve"] # dict mapping tenor->yield (percent)
tenors = list(points.keys())
yields = [points[t] for t in tenors]
JavaScript (fetch)
const url = new URL("https://bonds-api.com/api/v1/curve");
url.searchParams.set("country", "NO");
fetch(url.toString(), { headers: { "X-API-Key": "YOUR_API_KEY" } })
.then(r => r.json())
.then(json => {
// json.curve is an object like { "1M": 5.31, "3M": 5.27, ... } in percent
console.log(`As of ${json.date}, inverted=${json.inverted}`);
for (const [tenor, y] of Object.entries(json.curve)) {
console.log(`${tenor}: ${y}%`);
}
});
PHP (file_get_contents)
<?php
$ctx = stream_context_create([
"http" => ["method" => "GET", "header" => "X-API-Key: YOUR_API_KEY\r\n"]
]);
$url = "https://bonds-api.com/api/v1/curve?country=NO";
$resp = file_get_contents($url, false, $ctx);
$data = json_decode($resp, true);
$curve = $data["curve"]; // tenor => yield (percent)
$inverted = $data["inverted"] ? "true" : "false";
echo "Curve inverted: $inverted\n";
JSON response
Field notes:
- curve: map of tenor to yield (percent). Use this to plot a curve or fit a curve model.
- inverted: boolean flag indicating if the overall term structure is inverted.
- date: YYYY-MM-DD as-of date.
Comparing Select Maturities
| Maturity | Yield (percent) |
|---|---|
| 2Y | 4.25 |
| 5Y | 4.39 |
| 10Y | 4.52 |
| 30Y | 4.71 |
These are sample values from the curve response above. In your application, use the live API response to populate the table.
Endpoint: Intraday Yield Snapshots
When you need multiple updates within a trading day, request intraday snapshots by date and maturity. Timestamps are in UTC ISO 8601 format, which you can parse and convert to your local timezone if required.
cURL
Python (requests)
import requests
from datetime import datetime, timezone
params = {"country": "NO", "maturity": "10Y", "date": "2026-11-12"}
resp = requests.get(
"https://bonds-api.com/api/v1/intraday",
headers={"X-API-Key": "YOUR_API_KEY"},
params=params
)
data = resp.json()
snaps = data["snapshots"] # list of {yield: percent, fetched_at: ISO 8601 UTC, source: "market"}
for s in snaps:
ts = datetime.fromisoformat(s["fetched_at"].replace("Z", "+00:00"))
print(ts.astimezone(timezone.utc), s["yield"])
JavaScript (fetch)
const url = new URL("https://bonds-api.com/api/v1/intraday");
url.searchParams.set("country", "NO");
url.searchParams.set("maturity", "10Y");
url.searchParams.set("date", "2026-11-12");
fetch(url.toString(), { headers: { "X-API-Key": "YOUR_API_KEY" } })
.then(r => r.json())
.then(json => {
// fetched_at is ISO 8601 UTC (e.g., "2026-11-12T12:00:00Z")
console.log(`Snapshots: ${json.count}, TZ=${json.meta.timezone}`);
json.snapshots.forEach(s => console.log(`${s.fetched_at} - ${s.yield}%`));
});
PHP (file_get_contents)
<?php
$q = http_build_query([
"country" => "NO",
"maturity" => "10Y",
"date" => "2026-11-12"
]);
$ctx = stream_context_create([
"http" => ["method" => "GET", "header" => "X-API-Key: YOUR_API_KEY\r\n"]
]);
$resp = file_get_contents("https://bonds-api.com/api/v1/intraday?$q", false, $ctx);
$data = json_decode($resp, true);
foreach ($data["snapshots"] as $s) {
echo $s["fetched_at"]." - ".$s["yield"]."%\n";
}
JSON response
Field notes:
- yield: percent (e.g., 4.52 means 4.52%).
- fetched_at: UTC timestamp in ISO 8601 (Z suffix). Parse as UTC and convert if needed.
- count: number of snapshots in the array.
Endpoint: Fluctuation Over a Period
Summarize change, minimum, and maximum yields for Norway across a period. This is useful for risk monitoring, drawdown analysis, and concise reporting.
cURL
Python (requests)
import requests
params = {
"countries": "NO",
"maturity": "10Y",
"start": "2025-11-12",
"end": "2026-11-12"
}
resp = requests.get(
"https://bonds-api.com/api/v1/fluctuation",
headers={"X-API-Key": "YOUR_API_KEY"},
params=params
)
fx = resp.json()
no_stats = fx["data"]["NO"]
start_yield = no_stats["start_yield"] # percent
end_yield = no_stats["end_yield"] # percent
chg = no_stats["change"] # end - start (percent points)
lo = no_stats["min"] # percent
hi = no_stats["max"] # percent
JavaScript (fetch)
const url = new URL("https://bonds-api.com/api/v1/fluctuation");
url.searchParams.set("countries", "NO");
url.searchParams.set("maturity", "10Y");
url.searchParams.set("start", "2025-11-12");
url.searchParams.set("end", "2026-11-12");
fetch(url.toString(), { headers: { "X-API-Key": "YOUR_API_KEY" } })
.then(r => r.json())
.then(json => {
const s = json.data.NO;
console.log(`Change: ${s.change} pts (start=${s.start_yield}%, end=${s.end_yield}%, min=${s.min}%, max=${s.max}%)`);
});
PHP (file_get_contents)
<?php
$q = http_build_query([
"countries" => "NO",
"maturity" => "10Y",
"start" => "2025-11-12",
"end" => "2026-11-12"
]);
$ctx = stream_context_create([
"http" => ["method" => "GET", "header" => "X-API-Key: YOUR_API_KEY\r\n"]
]);
$resp = file_get_contents("https://bonds-api.com/api/v1/fluctuation?$q", false, $ctx);
$data = json_decode($resp, true);
$no = $data["data"]["NO"];
echo "NO 10Y change: {$no["change"]} pts\n";
JSON response
Field notes:
- All yield values are in percent; change is in percentage points (end minus start).
- Use this to generate quick summaries for dashboards and risk alerts.
How to Build a Norway Yield Curve and Use It
You have two main options to construct a yield curve:
- Call the curve endpoint to receive a ready cross-section of tenors and yields in one request.
- Call the latest endpoint specifying multiple maturities to assemble a curve subset.
If an endpoint supports multiple symbols/tenors in one call (e.g., latest with maturities=1Y,2Y,5Y,10Y,30Y), sort the tenors by their duration and connect them in a plot. For pricing or interpolation, fit a curve (e.g., cubic spline) to the tenors you have. Be aware of business days: if you stitch data from different endpoints, align dates to a consistent as-of date.
Cache curve responses per as-of date and invalidate with the next market day or when intraday monitoring dictates. For intraday-sensitive analytics, use intraday snapshots and backfill your state when a new snapshot arrives. Visit bonds-api.com for additional references and to explore more countries beyond Norway.
Error Handling and Operational Notes
All endpoints return JSON with success=true on success. Common error responses include:
- 401: Missing or invalid X-API-Key
- 403: Account quota exceeded
- 404: No data for requested country/maturity/date
- 422: Invalid parameter (e.g., date format not YYYY-MM-DD)
- 429: Rate limit exceeded
- 500: Server error
Recommended practices:
- Validate ISO2 country codes (Norway is NO) and maturity strings (e.g., 1M, 3M, 6M, 1Y, 2Y, 5Y, 10Y, 30Y).
- Parse yields as floats in percent. For spreads, interpret spread_bps as basis points.
- Read dates as UTC-based YYYY-MM-DD and timestamps as ISO 8601 with Z suffix where present (intraday).
- Back off and retry on 429s with an exponential strategy; log request IDs if an error payload includes them.
Real-World Use Cases
- Financial dashboards: Plot Norway’s curve and track the 2s10s slope using latest and curve endpoints.
- Portfolio risk tools: Stress-test exposures by replaying time series and fluctuation windows.
- Quant research: Study intraday volatility clustering on Norway 10Y using intraday snapshots and compute realized volatility.
- Cross-market RV: Compare Norway 10Y to US 10Y via the spread endpoint for hedge ratios and relative value screens.
Putting It Together: End-to-End Example
Here’s a minimal workflow to power a Norway yield curve widget with a spread overlay:
- Get the Norway curve via /curve to populate the curve line for the most recent day.
- Fetch latest Norway 10Y via /latest and compute an updated 2s10s slope using the 2Y and 10Y values.
- Call /spread with country=NO, benchmark=US, maturity=10Y to show the relative value to US Treasuries.
- For intraday updates, poll /intraday for NO 10Y and update the last point and the spread badge.
- At session end or for history view, call /timeseries and /fluctuation to display performance for the chosen window.
This workflow is easy to deploy and cache: daily endpoints can be cached longer, while intraday snapshots use shorter TTLs. Start integrating with your API key from Get started with Bonds API.
FAQ
How are yields expressed in the API?
All yields are percentages (e.g., 4.52 means 4.52%). Spreads are returned in basis points (bps), where 100 bps equals 1 percentage point.
What timezone are dates and timestamps in?
Dates in daily endpoints are YYYY-MM-DD without a time component. Intraday timestamps use ISO 8601 and are in UTC (Z suffix). Convert to your display timezone as needed.
What happens on weekends or Norwegian market holidays?
Daily endpoints reflect the latest available business-day data. Requests for a historical date with no observation for that date may return a 404 if that exact date is unavailable. Time series include only business-day observations within your range.
Can I request multiple maturities at once?
Yes. Use the latest endpoint with the maturities parameter (e.g., maturities=1Y,2Y,5Y,10Y,30Y). For a ready cross-section, use the curve endpoint, which returns a map of tenor to yield.
How should I cache responses?
Cache daily endpoints per as-of date and refresh on the next business day or when your workflow requires. For intraday, use shorter TTLs; snapshots are timestamped and may update several times per day.
If you’re ready to integrate Norway sovereign yields into your systems, get your API key and start building now: Register. You can also explore endpoints interactively via the MCP. For general info, visit bonds-api.com, and if you need a key, Register for Bonds API.