Euro Short-Term Rate API: ESTR as JSON

You need the Euro short-term benchmark inside your app and you don’t want to scrape, normalize, and babysit calendars. By the end of this guide you’ll be able to fetch ESTR as JSON with a single HTTP call, parse the fields you need, cache and store it safely, and plug the value into spreads or loan/payment formulas in your own code.

What you get: ESTR from the Interest Rates API

The Interest Rates API serves benchmark policy and money-market rates as JSON over HTTPS. For the Euro Short-Term Rate, use the symbol ESTR. Requests are authenticated with an api_key parameter and return machine-readable fields suitable for lending, treasury, and analytics pipelines.

If you also work with sovereign bond yields, note that the US 10Y is not here; it stays on Bonds-API. This article focuses only on ESTR via the Interest Rates API.

Pricing for production starts at Starter $19/mo with a 7-day trial so you can wire it up before deciding.

Quick start: go live in minutes

Steps

Register for an API key: Register — includes a 7-day trial.
Copy your api_key from the dashboard.
Call the “latest” endpoint with symbols=ESTR.
Store the value at rates.ESTR in your datastore for auditability and to avoid repeat network calls in hot paths.

Requesting the latest ESTR

The snippet below is a complete, copy-pasteable curl that requests the latest print for the ESTR symbol. Replace YOUR_API_KEY with your actual key.

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

If you prefer to integrate with application code, here is a minimal Python example that makes the same call and parses the response. Use the exact same URL and query string as in the curl above, including symbols=ESTR and your api_key.

# Python 3.x
import os
import requests

# Paste the exact URL from the curl above (including symbols=ESTR and your api_key)
url = "PASTE_THE_SAME_URL_AS_IN_THE_curl_ABOVE"

resp = requests.get(url, timeout=10)
data = resp.json()

# Basic guards
if not isinstance(data, dict) or not data.get("success", False):
    raise RuntimeError(f"ESTR request failed or returned success=false: {data}")

# Required fields
date = data.get("date")          # Effective (publication) date for this print
rates = data.get("rates", {})    # Container for rate values keyed by symbol
estr = rates.get("ESTR")         # The latest ESTR numeric value

if estr is None:
    raise KeyError("Expected rates.ESTR in the response")

print(f"ESTR on {date}: {estr}")

# Example: compute a simple spread against your internal margin (no numbers hardcoded)
def add_spread(base_rate, margin):
    return base_rate + margin

# Example: convert an annualized rate to a monthly payment factor (see formula notes below)
def monthly_payment(principal, annual_rate, term_months):
    r_m = annual_rate / 12.0
    if r_m == 0:
        return principal / term_months
    return principal * (r_m * (1 + r_m) ** term_months) / ((1 + r_m) ** term_months - 1)

Understanding the JSON response

The following is the official JSON from the latest response. It contains the fields your integration should read and validate.

{"success": true, "date": "2026-10-02", "base": "EUR", "rates": {"ESTR": 2.44}, "dates": {"ESTR": "2026-10-02"}, "currencies": {"ESTR": "EUR"}}

How to read it in your code:

success: Boolean indicating the call executed correctly on the API side. Always check this first; handle success=false by logging the error, backing off, and serving a cached value if available.
date: The effective date of the print. This is the date your system should associate with the returned ESTR value. If you query on a non-business day, this date can reflect the most recent available business day’s print.
rates: An object keyed by symbol. For ESTR, read rates.ESTR as a numeric value.

Units and interpretation:

The API returns a numeric rate for ESTR in the rates.ESTR field. Treat it as the benchmark rate you can feed into calculations. Do not assume additional scaling unless your own downstream systems require a specific format (for example, “percent” vs “decimal”). Use the value as delivered by the API.
Timezone: The date is provided without a time component in this payload. Treat it as the effective business date in the benchmark’s home calendar. If you snapshot intraday, always compare this date to your business date before updating live pricing.

Practical integration details that save time

Business days and publication cadence

Benchmarks like ESTR are published on a schedule aligned to the benchmark administrator and business-day calendars. You may query on weekends and holidays, but expect the API to return the latest available print with the date field reflecting the effective business date.

Production tip: schedule one fetch after the expected publication time for your region, plus a safety margin. If you must query before publication, keep serving the last stored value and reconcile when the new print appears.

Caching and storage strategy

Cache by symbol and effective date. A simple key like ESTR:YYYY-MM-DD helps avoid duplicate inserts and speeds up hot reads.
Always persist the raw JSON alongside parsed fields for audit trails and debugging.
Use a short TTL cache (for example, one trading day) for the latest endpoint; bust the cache only when the date changes or if success=false indicates a retry is needed.

Error handling and missing values

Check success. If it’s false, do not trust other fields; log the payload and back off before retrying.
Guard against missing rates.ESTR. If absent or null, serve your last known good value and alert.
Network timeouts should not break pricing: use a circuit-breaker and fall back to cached data.

How to compute spreads and derived values

You often need to combine ESTR with a margin or transform it for loan pricing. The following conventions keep your math clean and testable without relying on hardcoded sample numbers.

Spread over ESTR: let r be rates.ESTR as returned; let m be your margin. The all-in rate is r_all_in = r + m.
Monthly payment from an annualized rate: given principal P, annual rate R (use r_all_in from above), and term in months n:
- If R = 0, payment = P / n.
- Otherwise, r_m = R / 12, payment = P * [ r_m (1 + r_m)^n / ( (1 + r_m)^n – 1 ) ].
Discounting cash flows monthly: discount factor for month t is 1 / (1 + r_m)^t with r_m as above.

Keep the units consistent. If your downstream uses “percent,” convert the numeric rate accordingly in one place (for example, multiply by 100 when presenting to users) and keep storage and internal math in a single canonical representation.

Environment hardening: deployments, SLAs, and audits

Idempotency: write your upsert to key on (symbol, date). This ensures replays and retries don’t create duplicates.
Monitoring: alert when the new business day arrives and your stored date has not advanced after your fetch schedule.
Drift checks: if your internal “expected” publication window passes without a new print, keep the last value, log the anomaly, and continue polling with exponential backoff.
Observability: tag logs with symbol=ESTR and request_id (if provided by your stack) to correlate errors.

Going beyond the latest print

The Interest Rates API also exposes endpoints for available symbols, historical values, time series, fluctuation, and OHLC. Use the latest endpoint to bootstrap and cache ESTR each business day; add historical/time-series endpoints when you need backfills, windows for analytics, or comparisons across periods. For integration specifics and method details, see MCP.

Field-by-field checklist for production

Input: api_key parameter present and kept outside source control (for example, environment vars or secret manager).
Query: symbols=ESTR set; avoid requesting unrelated symbols in the same call to keep payloads small.
Response validation: success is true, date is present, rates is an object, rates.ESTR is a numeric value.
Storage: persist date, rates.ESTR, the full raw JSON, and a created_at timestamp in UTC from your system clock.
Caching: key by ESTR and date; expire caches at the first fetch of the next business day.
Fallback: if success=false or missing rates.ESTR, serve the previous stored value and retry with backoff.

End-to-end example flow

At your scheduled time, request latest with symbols=ESTR and your api_key.
Verify success is true; extract date and rates.ESTR.
If date equals yesterday’s stored date and it’s still the same business day, skip updates; otherwise, upsert (ESTR, date, value).
Update your pricing engine’s in-memory cache with the new value and the effective date.
Downstream: compute r_all_in = rates.ESTR + margin; then compute monthly payment or discount factors as needed.

Security and governance

Keep api_key out of logs. Redact query strings in centralized logging if you log URLs.
Set tight timeouts (connect and read) on HTTP clients and restrict egress to known API domains.
Record the effective date from the payload as your “as-of” date for audit and reconciliation.

FAQ

Which symbol should I use for the Euro Short-Term Rate?
Use symbols=ESTR in your requests. Read the numeric value from rates.ESTR in the JSON response.

What date should I store?
Store the date field from the response as the effective date. This is the print you should attribute to that business day in your systems.

How often does ESTR update?
Expect updates aligned to the benchmark’s official publication schedule and business-day calendars. If you query on weekends or holidays, you will receive the most recent available print; the date reflects that.

What if the API returns success=false or rates.ESTR is missing?
Treat the call as failed, serve the last known good value from storage, log the incident, and retry with exponential backoff. Do not overwrite stored values with partial or failed responses.

Can I use ESTR directly in loan or savings calculations?
Yes. Combine rates.ESTR with your product margin to form an all-in rate (r + m). Use that rate in your monthly payment or discounting formulas. Keep units consistent end-to-end (decimals vs percents) and document conversions in one place.

Ready to ship ESTR into your app? Start your 7-day trial and get an API key here: Register. For method details and additional endpoints, see MCP.