Poland Yield Curve

Poland Yield Curve

You need reliable, machine-readable Polish government bond yields you can feed directly into models, charts, and risk tools. By the end of this post, you’ll be able to fetch Poland’s latest yields, build a full PLN yield curve, compute spreads, and analyze daily and intraday moves using Bonds API’s REST endpoints.

What you can pull for Poland, and how yields are expressed

Bonds API provides sovereign bond yields as JSON via HTTPS. For Poland (ISO2: PL), you can retrieve:

Illustration: Poland Yield Curve
  • Latest point-in-time yields for specific maturities or the entire curve
  • Historical yields for a given date
  • Time series over date ranges
  • Intraday snapshots (UTC timestamps)
  • Spreads versus benchmarks (e.g., US Treasuries)
  • Period fluctuations (change, min, max) for risk and performance analysis

Yields are expressed in percent (e.g., 4.52 means 4.52%). Spreads are delivered in basis points (bps), where 1 bp = 0.01%. Dates in daily endpoints are YYYY-MM-DD. Intraday snapshots include an ISO 8601 timestamp with timezone: “Z” denotes UTC.

All endpoints are GET, under the base URL https://bonds-api.com/api/v1/ and require the X-API-Key HTTP header. You can explore the platform at bonds-api.com and manage API credentials in the MCP. To start building, request an API key: Register or Get started with Bonds API.

Poland fundamentals you’ll use in analytics

Polish government bonds are issued by the Republic of Poland and are priced in PLN. Yield variations reflect monetary policy expectations, inflation dynamics, and global risk appetite. Analysts often compare Poland’s curve shape (e.g., slope 2Y–10Y) and cross-market spreads (PL vs US or DE) to understand local and global rate conditions.

Endpoint: Latest yields for Poland

Fetch current yields for selected maturities or all available maturities. Useful for dashboards and real-time curve monitors. Units: percent. Dates are in YYYY-MM-DD (business date of the observation).

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": "PL", "maturities": "2Y,10Y"}
)
data = resp.json()
# Access yields as percentages
pl_2y = data["data"]["PL"]["2Y"]["yield"]
pl_10y = data["data"]["PL"]["10Y"]["yield"]
obs_date = data["data"]["PL"]["10Y"]["date"]

JavaScript (fetch)

const url = new URL("https://bonds-api.com/api/v1/latest");
url.searchParams.set("countries", "PL");
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 pl2y = json.data.PL["2Y"].yield; // percent
const pl10y = json.data.PL["10Y"].yield; // percent
const date = json.data.PL["10Y"].date; // YYYY-MM-DD
console.log({ pl2y, pl10y, date });
});

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=PL&maturities=2Y,10Y";
$json = file_get_contents($url, false, $context);
$data = json_decode($json, true);
$pl10y = $data["data"]["PL"]["10Y"]["yield"];
$date = $data["data"]["PL"]["10Y"]["date"];
echo "PL 10Y: $pl10y% on $date\n";

Sample JSON response

{
    "success": true,
    "date": "2026-10-27",
    "rates": {
        "US_10Y": 4.992
    },
    "dates": {
        "US_10Y": "2026-10-27"
    },
    "currencies": {
        "US_10Y": "USD"
    },
    "meta": {
        "request_id": "8df0468c-dd25-4a10-b3c8-48221cf15ebe",
        "timestamp": "2026-10-27T00:06:37+00:00"
    }
}

Field notes:

  • yield: percentage value (e.g., 4.52 means 4.52%)
  • date: business date of the observation (YYYY-MM-DD)
  • source: data origin label (e.g., “official”)

Endpoint: Historical yield on a specific date (Poland)

Pull the yield for Poland and a given maturity on a target date. Ideal for point-in-time backfills and return calculations.

cURL

Python (requests)

import requests

params = {"country": "PL", "maturity": "10Y", "date": "2025-06-15"}
r = requests.get(
"https://bonds-api.com/api/v1/historical",
headers={"X-API-Key": "YOUR_API_KEY"},
params=params
)
hist = r.json()
pl10y = hist["yield"] # percent
obs_date = hist["date"] # "2025-06-15"

JavaScript (fetch)

const q = new URL("https://bonds-api.com/api/v1/historical");
q.searchParams.set("country", "PL");
q.searchParams.set("maturity", "10Y");
q.searchParams.set("date", "2025-06-15");

fetch(q, { headers: { "X-API-Key": "YOUR_API_KEY" } })
.then(r => r.json())
.then(j => {
console.log(j.country, j.maturity, j.date, j.yield);
});

PHP (file_get_contents)

<?php
$ctx = stream_context_create([
"http" => ["header" => "X-API-Key: YOUR_API_KEY\r\n"]
]);
$url = "https://bonds-api.com/api/v1/historical?country=PL&maturity=10Y&date=2025-06-15";
$data = json_decode(file_get_contents($url, false, $ctx), true);
echo "PL " . $data["maturity"] . " on " . $data["date"] . ": " . $data["yield"] . "%\n";

Sample JSON response

Endpoint: Time series for Poland

Request a date-bounded series for Poland and one maturity. Use this for charting, regressions, risk modeling, and seasonal analysis. Dates are inclusive; yields are in percent.

cURL

Python (requests)

import requests

args = {
"country": "PL",
"maturity": "10Y",
"start": "2025-10-27",
"end": "2026-10-27"
}
res = requests.get(
"https://bonds-api.com/api/v1/timeseries",
headers={"X-API-Key": "YOUR_API_KEY"},
params=args
).json()

series = res["series"] # list of { "date": "YYYY-MM-DD", "yield": float }

JavaScript (fetch)

const ts = new URL("https://bonds-api.com/api/v1/timeseries");
Object.entries({
country: "PL",
maturity: "10Y",
start: "2025-10-27",
end: "2026-10-27"
}).forEach(([k, v]) => ts.searchParams.set(k, v));

fetch(ts, { headers: { "X-API-Key": "YOUR_API_KEY" } })
.then(r => r.json())
.then(({ series }) => {
for (const row of series) {
// row.yield in percent; row.date is YYYY-MM-DD
}
});

PHP (file_get_contents)

<?php
$ctx = stream_context_create([
"http" => ["header" => "X-API-Key: YOUR_API_KEY\r\n"]
]);
$url = "https://bonds-api.com/api/v1/timeseries?country=PL&maturity=10Y&start=2025-10-27&end=2026-10-27";
$json = file_get_contents($url, false, $ctx);
$ts = json_decode($json, true)["series"];
foreach ($ts as $row) {
// $row["date"], $row["yield"]
}

Sample JSON response

Endpoint: Spread versus a benchmark

Compare Poland to a benchmark sovereign, commonly the US (US Treasuries) or DE (German Bunds). The result includes:

  • spread_bps: spread in basis points (1 bp = 0.01%)
  • country_yield and benchmark_yield: both in percent

cURL

Python (requests)

import requests

s = requests.get(
"https://bonds-api.com/api/v1/spread",
headers={"X-API-Key": "YOUR_API_KEY"},
params={"country": "PL", "benchmark": "US", "maturity": "10Y"}
).json()

spread_bps = s["spread_bps"] # integer/float bps
pl_y = s["country_yield"] # percent
us_y = s["benchmark_yield"] # percent

JavaScript (fetch)

const sp = new URL("https://bonds-api.com/api/v1/spread");
sp.searchParams.set("country", "PL");
sp.searchParams.set("benchmark", "US");
sp.searchParams.set("maturity", "10Y");

fetch(sp, { headers: { "X-API-Key": "YOUR_API_KEY" } })
.then(r => r.json())
.then(j => {
// j.spread_bps in basis points
});

PHP (file_get_contents)

<?php
$ctx = stream_context_create([
"http" => ["header" => "X-API-Key: YOUR_API_KEY\r\n"]
]);
$url = "https://bonds-api.com/api/v1/spread?country=PL&benchmark=US&maturity=10Y";
$resp = json_decode(file_get_contents($url, false, $ctx), true);
printf("PL vs US 10Y spread: %d bps\n", $resp["spread_bps"]);

Sample JSON response

Endpoint: Full Poland yield curve

Get an entire curve snapshot for Poland. Great for bootstrapping, curve visualizations, and detecting inversion. The response includes an “inverted” boolean flag to quickly screen for inversion.

cURL

Python (requests)

import requests

curve = requests.get(
"https://bonds-api.com/api/v1/curve",
headers={"X-API-Key": "YOUR_API_KEY"},
params={"country": "PL"}
).json()

date = curve["date"] # YYYY-MM-DD
is_inverted = curve["inverted"]
pl_curve = curve["curve"] # dict of maturity -> yield (percent)

JavaScript (fetch)

const u = new URL("https://bonds-api.com/api/v1/curve");
u.searchParams.set("country", "PL");

fetch(u, { headers: { "X-API-Key": "YOUR_API_KEY" } })
.then(r => r.json())
.then(({ date, inverted, curve }) => {
// curve["2Y"], curve["10Y"], etc. as percent
});

PHP (file_get_contents)

<?php
$ctx = stream_context_create([
"http" => ["header" => "X-API-Key: YOUR_API_KEY\r\n"]
]);
$url = "https://bonds-api.com/api/v1/curve?country=PL";
$data = json_decode(file_get_contents($url, false, $ctx), true);
$curve = $data["curve"];
// Example: echo "2Y: {$curve["2Y"]}% 10Y: {$curve["10Y"]}%\n";

Sample JSON response

Using /latest to construct a curve

If you prefer, you can also build a curve using /latest by requesting multiple maturities at once. For example, maturities=1M,3M,6M,1Y,2Y,5Y,10Y,30Y will deliver a cross-section you can sort and plot. The /curve endpoint is simpler when you want the canonical country curve and inversion flag in one response.

Endpoint: Intraday snapshots (Poland)

Track within-day changes for a single maturity. Each snapshot includes:

  • yield: percent
  • fetched_at: ISO 8601 UTC timestamp (e.g., 2026-10-27T12:00:00Z)
  • source: market data provider label

cURL

Python (requests)

import requests

snap = requests.get(
"https://bonds-api.com/api/v1/intraday",
headers={"X-API-Key": "YOUR_API_KEY"},
params={"country": "PL", "maturity": "10Y", "date": "2026-10-27"}
).json()

for s in snap["snapshots"]:
# s["yield"] in percent, s["fetched_at"] in UTC ISO 8601
pass

JavaScript (fetch)

const intr = new URL("https://bonds-api.com/api/v1/intraday");
intr.searchParams.set("country", "PL");
intr.searchParams.set("maturity", "10Y");
intr.searchParams.set("date", "2026-10-27");

fetch(intr, { headers: { "X-API-Key": "YOUR_API_KEY" } })
.then(r => r.json())
.then(j => {
// j.snapshots: [{ yield, fetched_at, source }]
});

PHP (file_get_contents)

<?php
$ctx = stream_context_create([
"http" => ["header" => "X-API-Key: YOUR_API_KEY\r\n"]
]);
$url = "https://bonds-api.com/api/v1/intraday?country=PL&maturity=10Y&date=2026-10-27";
$data = json_decode(file_get_contents($url, false, $ctx), true);
foreach ($data["snapshots"] as $s) {
// $s["yield"], $s["fetched_at"], $s["source"]
}

Sample JSON response

Endpoint: Fluctuation over a period

Compute start, end, absolute change, and range (min, max) for Poland over a period. Useful for risk summaries, weekly/monthly report cards, or alerting when ranges widen.

cURL

Python (requests)

import requests

fl = requests.get(
"https://bonds-api.com/api/v1/fluctuation",
headers={"X-API-Key": "YOUR_API_KEY"},
params={"countries": "PL", "maturity": "10Y", "start": "2025-10-27", "end": "2026-10-27"}
).json()

stats = fl["data"]["PL"]
# stats: start_yield, end_yield, change, min, max (all in percent)

JavaScript (fetch)

const f = new URL("https://bonds-api.com/api/v1/fluctuation");
Object.entries({
countries: "PL",
maturity: "10Y",
start: "2025-10-27",
end: "2026-10-27"
}).forEach(([k, v]) => f.searchParams.set(k, v));

fetch(f, { headers: { "X-API-Key": "YOUR_API_KEY" } })
.then(r => r.json())
.then(j => {
const pl = j.data.PL;
// pl.start_yield, pl.end_yield, pl.change, pl.min, pl.max
});

PHP (file_get_contents)

<?php
$ctx = stream_context_create([
"http" => ["header" => "X-API-Key: YOUR_API_KEY\r\n"]
]);
$url = "https://bonds-api.com/api/v1/fluctuation?countries=PL&maturity=10Y&start=2025-10-27&end=2026-10-27";
$resp = json_decode(file_get_contents($url, false, $ctx), true);
$pl = $resp["data"]["PL"];
printf("Change: %.2f%%, Range: [%.2f%%, %.2f%%]\n", $pl["change"], $pl["min"], $pl["max"]);

Sample JSON response

Practical production notes for Poland yield integrations

  • Business days and holidays: Daily yields typically reflect local market business days. Expect gaps on Polish public holidays and weekends; time series endpoints will simply omit those dates.
  • Update cadence: Latest and curve endpoints reflect the most recent available market or official close updates. Intraday snapshots provide multiple points throughout a UTC day; check the “fetched_at” field.
  • Caching: If you render dashboards, cache /latest or /curve for short intervals intra-day and refresh more frequently around local market hours. For time series used in batch analytics, cache by date to avoid refetching identical data.
  • Maturity handling: Use exact maturity codes (e.g., 1M, 3M, 6M, 1Y, 2Y, 5Y, 10Y, 30Y). When building a custom curve from /latest, always sort by tenor order before plotting.
  • Error handling: Check success=false and handle HTTP 401/403/404/422/429/500 gracefully. Consider retries with backoff for 429 or transient 5xx errors.
  • Spreads: spread_bps is basis points. For portfolio attribution, multiply spread in percent terms by duration to estimate PnL impact, or use spread_bps/10000 as a decimal.

Compare Poland maturities in one snapshot

When you need a quick comparative view, prefer /curve. Example of maturities you will commonly chart together:

Maturity Short Bills Notes Long Bonds
Examples 1M, 3M, 6M 1Y, 2Y, 5Y, 10Y 30Y

Official sample (verbatim from a live sibling)

The following official sample shows a latest-yield call schema for a sibling market. Copying verbatim for reference:

Field notes:

  • rates: yields in percent by symbol key
  • dates: observation dates keyed by the same symbol
  • meta.timestamp: ISO 8601 with UTC offset

Use cases: how teams wire Poland yield data

  • Financial dashboards: Show PL 2Y/5Y/10Y with daily change and intraday ticks. Use /latest for the headline, /intraday for a sparkline.
  • Portfolio risk: Pull /curve to compute key rate durations, scenario shocks, and curve-slope factors (2s10s, 5s30s). Validate shape with inverted=false/true.
  • Economic research: Use /timeseries for regressions (e.g., yields vs CPI prints), and /fluctuation for rolling windows (weekly/monthly volatility).
  • Cross-market analysis: Combine /spread (PL vs US or DE) with /timeseries to decompose drivers between local and global rate moves.

Manage and monitor your keys in the MCP. Explore the platform at bonds-api.com and Register for an API key when you are ready to integrate.

Error responses you should handle

  • 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)
  • 429: Rate limit exceeded
  • 500: Server error

Always check the success flag. On errors, the payload includes error with a message string. Log request parameters alongside request_id if provided in meta for traceability.

Reading dates, timestamps, and currencies

  • Daily endpoints: date fields are YYYY-MM-DD and correspond to the market or official close date for Poland.
  • Intraday: fetched_at is ISO 8601 with a “Z” suffix (UTC). Convert to local timezones in UI layers if needed.
  • Currency: Poland government bonds are PLN instruments. When spreads reference a benchmark (e.g., US), each yield remains in its local market context; spread is purely a yield difference in bps.

Building a Poland yield curve from multiple symbols

Two approaches:

  • Use /curve with country=PL to get a canonical set plus inverted flag. Simplest path.
  • Use /latest with country list and maturities=1M,3M,6M,1Y,2Y,5Y,10Y,30Y, then order maturities numerically. This is useful when combining countries in a single call.

For analytics, compute slopes like 2s10s = curve[“10Y”] - curve[“2Y”] (in percent). To convert a slope to bps, multiply by 100.

FAQ

Q: Are yields delivered as decimals or percentages?
A: Percentages. For example, 4.52 means 4.52%.

Q: How do I interpret spread_bps?
A: It is in basis points. 25 bps equals 0.25 percentage points.

Q: What timezone are intraday timestamps in?
A: UTC. The fetched_at field is ISO 8601 with a “Z” suffix.

Q: What happens on Polish holidays and weekends?
A: Daily series will skip non-business days. Use timeseries to iterate over available dates; do not assume continuity across calendar days.

Q: How should I authenticate?
A: Include your API key in the X-API-Key HTTP header for GET requests to https://bonds-api.com/api/v1/ endpoints.

Start integrating Poland’s curve into your models now. Explore the documentation at bonds-api.com and get your credentials here: Register. For key and project management, visit the MCP. Also see: Register for Bonds API.

Start building with bond data today

Get your API key and access sovereign bond yields across 60+ countries. 7-day free trial, no credit card required.

Related posts

All posts →