ECB Deposit Facility (ECB_DEPOSIT) Rate Change

ECB Deposit Facility (ECB_DEPOSIT) Rate Change

You need to detect, fetch, and work with changes to the ECB Deposit Facility rate (ECB_DEPOSIT) inside your software—fast, reliably, and with code you can ship today. By the end of this guide you’ll request the latest and historical ECB_DEPOSIT values, build time series and OHLC views, compute spreads and simple loan costs, and productionize the integration using the Interest Rates API endpoints, response fields, and caching/rate-limit practices.

What the ECB_DEPOSIT rate is and how it’s represented in the API

ECB_DEPOSIT is the European Central Bank’s Deposit Facility rate. It matters because it anchors the ECB’s policy corridor and directly influences overnight market rates in EUR, bank funding, lending benchmarks, and the transmission of monetary policy to the real economy. Developers use it as a policy input to pricing models, risk systems, treasury dashboards, and mortgage or lending applications.

Illustration: ECB Deposit Facility (ECB_DEPOSIT) Rate Change

In the Interest Rates API, ECB_DEPOSIT is a central bank symbol with daily frequency. The rate is returned as a numeric value (percentage per annum) and is expressed in the “rates” map keyed by symbol. Dates are ISO 8601 strings in YYYY-MM-DD (Y-m-d) format. Use the “dates” map (when present) to attribute the effective date per symbol, and the “currencies” map to understand the base currency code (EUR for ECB_DEPOSIT).

How often the ECB_DEPOSIT rate updates, effective dates, and business days

ECB policy rates are updated on an event-driven schedule (policy decisions) and then persist day-to-day at their prevailing level. The Interest Rates API exposes ECB_DEPOSIT at daily frequency: each business day will report the prevailing value; non-business days will reflect the last available value in time series queries covering those ranges.

Effective dates: rely on the “dates” map (when present) or the frame of the endpoint to interpret timing. For example, /latest returns a single date field representing the evaluation date and may also include a per-symbol “dates” map. For /historical, the “date” matches your requested day. For /timeseries and /ohlc, the returned dates or periods identify the observation frames to which each value applies.

Base URL, authentication, and request method

  • Base URL: https://interestratesapi.com/api/v1/
  • Authentication: api_key query parameter (e.g., ?api_key=YOUR_API_KEY)
  • HTTP method: GET for all endpoints (never POST)

All examples below call only https://interestratesapi.com. For deeper reference, see the MCP and visit the homepage at interestratesapi.com.

Discover available symbols (filter to central bank and EUR): /symbols

Use /symbols to discover what’s available or to verify attributes such as frequency and currency. You can filter by category and currency. Below is an example from the documentation that shows the response structure.

cURL

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

JSON response

{
    "success": true,
    "date": "2026-10-24",
    "base": "EUR",
    "rates": {
        "ECB_DEPOSIT": 2.5
    },
    "dates": {
        "ECB_DEPOSIT": "2026-10-24"
    },
    "currencies": {
        "ECB_DEPOSIT": "EUR"
    },
    "base_filter_note": null
}

Key fields you’ll use:

  • symbol: identifier to use in subsequent requests (e.g., ECB_DEPOSIT).
  • frequency: for ECB_DEPOSIT this is “daily.”
  • currency_code: policy currency (EUR for ECB_DEPOSIT).

Python (requests)

import requests

resp = requests.get(
'https://interestratesapi.com/api/v1/symbols',
params=dict(category='central_bank', base='EUR', api_key='YOUR_API_KEY')
)
data = resp.json()
print(data.get('success'), len(data.get('symbols', [])))

JavaScript (fetch)

const url = 'https://interestratesapi.com/api/v1/symbols?category=central_bank&base=EUR&api_key=YOUR_API_KEY';
const response = await fetch(url);
const data = await response.json();
console.log(data.success, data.count);

PHP

<?php
$url = 'https://interestratesapi.com/api/v1/symbols?category=central_bank&base=EUR&api_key=YOUR_API_KEY';
$resp = file_get_contents($url);
$data = json_decode($resp, true);
echo $data['success'] ? "ok\n" : "error\n";

Get the latest ECB_DEPOSIT value: /latest

This endpoint returns the most recent value and its effective date. The official sample below must be used verbatim.

cURL (official sample)

JSON response (official sample)

How to read it:

  • rates map: numerical value for ECB_DEPOSIT, in percent per annum.
  • date: reference date of the response; dates.ECB_DEPOSIT: effective date for the symbol.
  • currencies map: “EUR” for ECB_DEPOSIT.

Python (requests)

import requests

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

JavaScript (fetch)

const res = await fetch(
'https://interestratesapi.com/api/v1/latest?api_key=YOUR_API_KEY&symbols=ECB_DEPOSIT'
);
const data = await res.json();
const rate = data.rates.ECB_DEPOSIT;
const effectiveDate = data.dates.ECB_DEPOSIT;
console.log('ECB_DEPOSIT', rate, effectiveDate);

PHP

<?php
$u = 'https://interestratesapi.com/api/v1/latest?api_key=YOUR_API_KEY&symbols=ECB_DEPOSIT';
$body = file_get_contents($u);
$data = json_decode($body, true);
$rate = $data['rates']['ECB_DEPOSIT'];
$date = $data['dates']['ECB_DEPOSIT'];
echo "ECB_DEPOSIT $rate on $date\n";

Query a specific decision date: /historical

Use /historical when you need the value on a particular date (Y-m-d). For ECB_DEPOSIT, this is useful to track specific Governing Council decisions or to validate backtests at quarter-ends or month-ends.

cURL

JSON response

Fields to note:

  • date: the exact date you requested.
  • rates map: the rate for that date.
  • currencies: currency of the rate; use it to format or label outputs correctly.

Python (requests)

import requests

params = dict(date='2025-06-15', symbols='ECB_DEPOSIT', api_key='YOUR_API_KEY')
r = requests.get('https://interestratesapi.com/api/v1/historical', params=params)
data = r.json()
print(data['date'], data['rates']['ECB_DEPOSIT'])

JavaScript (fetch)

const urlH = 'https://interestratesapi.com/api/v1/historical?date=2025-06-15&symbols=ECB_DEPOSIT&api_key=YOUR_API_KEY';
const respH = await fetch(urlH);
const hist = await respH.json();
console.log(hist.date, hist.rates.ECB_DEPOSIT);

PHP

<?php
$h = 'https://interestratesapi.com/api/v1/historical?date=2025-06-15&symbols=ECB_DEPOSIT&api_key=YOUR_API_KEY';
$j = json_decode(file_get_contents($h), true);
echo $j['date'] . ' ' . $j['rates']['ECB_DEPOSIT'] . "\n";

Build a time series for analysis or charts: /timeseries

Use /timeseries to collect day-by-day ECB_DEPOSIT values between start and end. This is the backbone for dashboards, stress testing, and factor models.

cURL

JSON response

Key fields:

  • rates[symbol][date]: date-keyed observations.
  • frequencies: frequency per symbol; ECB_DEPOSIT is daily.
  • start_date/end_date: the inclusive range actually used in the response.

Python (requests)

import requests

p = dict(start='2025-10-25', end='2026-10-25', symbols='ECB_DEPOSIT', api_key='YOUR_API_KEY')
resp = requests.get('https://interestratesapi.com/api/v1/timeseries', params=p)
series = resp.json()['rates']['ECB_DEPOSIT']
for d, v in list(series.items())[:3]:
print(d, v)

JavaScript (fetch)

const tsUrl = 'https://interestratesapi.com/api/v1/timeseries?start=2025-10-25&end=2026-10-25&symbols=ECB_DEPOSIT&api_key=YOUR_API_KEY';
const tsResp = await fetch(tsUrl);
const ts = await tsResp.json();
const entries = Object.entries(ts.rates['ECB_DEPOSIT']).slice(0, 3);
console.log(entries);

PHP

<?php
$ts = 'https://interestratesapi.com/api/v1/timeseries?start=2025-10-25&end=2026-10-25&symbols=ECB_DEPOSIT&api_key=YOUR_API_KEY';
$tsData = json_decode(file_get_contents($ts), true);
$points = $tsData['rates']['ECB_DEPOSIT'];
foreach (array_slice($points, 0, 3) as $date => $val) {
echo "$date $val\n";
}

Summarize changes over a range: /fluctuation

Use /fluctuation to quickly calculate start/end values, absolute and percentage change, as well as highs and lows for ECB_DEPOSIT over a range. This is efficient for alerting, email summaries, or lightweight dashboards.

cURL

JSON response

Fields to note:

  • start_value/end_value: values at the range boundaries.
  • change, change_pct: absolute and percent change across the range.
  • high/low: observed extrema within the range.

Python (requests)

import requests

params = dict(start='2025-10-25', end='2026-10-25', symbols='ECB_DEPOSIT', api_key='YOUR_API_KEY')
r = requests.get('https://interestratesapi.com/api/v1/fluctuation', params=params)
fx = r.json()['rates']['ECB_DEPOSIT']
print(fx['start_value'], fx['end_value'], fx['change_pct'])

JavaScript (fetch)

const flUrl = 'https://interestratesapi.com/api/v1/fluctuation?start=2025-10-25&end=2026-10-25&symbols=ECB_DEPOSIT&api_key=YOUR_API_KEY';
const flRes = await fetch(flUrl);
const fl = await flRes.json();
console.log(fl.rates['ECB_DEPOSIT'].high, fl.rates['ECB_DEPOSIT'].low);

PHP

<?php
$fl = 'https://interestratesapi.com/api/v1/fluctuation?start=2025-10-25&end=2026-10-25&symbols=ECB_DEPOSIT&api_key=YOUR_API_KEY';
$data = json_decode(file_get_contents($fl), true)['rates']['ECB_DEPOSIT'];
echo "chg=" . $data['change'] . " pct=" . $data['change_pct'] . "\n";

Compute period OHLC candlesticks: /ohlc

/ohlc aggregates daily ECB_DEPOSIT values into open, high, low, close over a specified period (weekly, monthly, quarterly). This is computed on-the-fly from daily series and is convenient for visualization or coarse trend analysis.

cURL

JSON response

Fields to note:

  • period: aggregation window (e.g., “2025-01” for monthly).
  • open/high/low/close: derived from daily data.
  • data_points: number of daily observations used in the aggregation window.

Python (requests)

import requests

p = dict(symbols='ECB_DEPOSIT', period='monthly', start='2025-10-25', end='2026-10-25', api_key='YOUR_API_KEY')
r = requests.get('https://interestratesapi.com/api/v1/ohlc', params=p)
ohlc = r.json()['rates']['ECB_DEPOSIT']
for bar in ohlc:
print(bar['period'], bar['open'], bar['close'], bar['data_points'])

JavaScript (fetch)

const ohlcUrl = 'https://interestratesapi.com/api/v1/ohlc?symbols=ECB_DEPOSIT&period=monthly&start=2025-10-25&end=2026-10-25&api_key=YOUR_API_KEY';
const oRes = await fetch(ohlcUrl);
const o = await oRes.json();
(o.rates['ECB_DEPOSIT'] || []).forEach(b => {
console.log(b.period, b.open, b.high, b.low, b.close);
});

PHP

<?php
$u = 'https://interestratesapi.com/api/v1/ohlc?symbols=ECB_DEPOSIT&period=monthly&start=2025-10-25&end=2026-10-25&api_key=YOUR_API_KEY';
$d = json_decode(file_get_contents($u), true);
foreach ($d['rates']['ECB_DEPOSIT'] as $bar) {
echo $bar['period'] . ' O:' . $bar['open'] . ' C:' . $bar['close'] . "\n";
}

Compare simple loan costs across benchmarks: /convert

/convert compares total interest cost for a simple loan using the latest rates of two symbols. You can use ECB_DEPOSIT against another ECB benchmark to estimate spread-driven differences in interest expense.

cURL

JSON response

How to use it:

  • from/to.rate: latest rates used in the calculation (percent per annum).
  • total_interest, total_payment: simple-loan cost calculation over term_months.
  • difference.rate_spread: arithmetic spread (from.rate - to.rate).

Python (requests)

import requests

args = dict(from='ECB_DEPOSIT', to='ECB_MRO', amount=100000, term_months=12, api_key='YOUR_API_KEY')
r = requests.get('https://interestratesapi.com/api/v1/convert', params=args)
cmp = r.json()
print(cmp['difference']['rate_spread'], cmp['difference']['interest_saved'])

JavaScript (fetch)

const cUrl = 'https://interestratesapi.com/api/v1/convert?from=ECB_DEPOSIT&to=ECB_MRO&amount=100000&term_months=12&api_key=YOUR_API_KEY';
const cRes = await fetch(cUrl);
const conv = await cRes.json();
console.log(conv.difference.rate_spread, conv.difference.interest_saved);

PHP

<?php
$c = 'https://interestratesapi.com/api/v1/convert?from=ECB_DEPOSIT&to=ECB_MRO&amount=100000&term_months=12&api_key=YOUR_API_KEY';
$j = json_decode(file_get_contents($c), true);
echo $j['difference']['rate_spread'] . ' ' . $j['difference']['interest_saved'] . "\n";

Practical computation notes: spreads, monthly payments, and effective dates

Spreads: to compute a spread between ECB_DEPOSIT and another rate (e.g., ECB_MRO), fetch both via /latest (symbols=ECB_DEPOSIT,ECB_MRO) and subtract: spread = rates[“ECB_DEPOSIT”] − rates[“ECB_MRO”]. Always attach the per-symbol effective date from the “dates” map to avoid mixing stale values.

Monthly simple payment estimates: if you want a rough monthly interest-only payment at the latest ECB_DEPOSIT value for amount A, use monthly_interest = A × (rate/100) ÷ 12. For amortizing loans, use an amortization formula and the annual percentage from “rates[symbol]” transformed into a monthly nominal (rate/100/12). The API’s /convert endpoint already implements a simple-loan interest comparison—use it for fast what-if analysis based on the latest rates.

Caching, business days, and rate limits

Caching: ECB_DEPOSIT will not change intraday under normal circumstances. Cache /latest results through your risk window (e.g., a few minutes to hours) and invalidate on market open schedules relevant to your users. For backfills, cache immutable /historical snapshots aggressively.

Non-business days: ECB_DEPOSIT is daily frequency but policy changes do not occur every day. Time series will reflect the prevailing value on business days within your date range. When aggregating to OHLC, the data_points field shows how many daily observations contributed to each period.

Rate limits and retries: handle 429 with the Retry-After header, and monitor X-RateLimit-Limit, X-RateLimit-Remaining, and X-RateLimit-Reset to shape client-side throttling. For 401/403/404/422 errors, surface the “error” string (and “details” when present) to logs and user-facing diagnostics where appropriate.

Error handling examples

  • 401 unauthorized: ensure api_key is appended as a query parameter.
  • 403 forbidden: the account may be inactive.
  • 404 not found: symbol typo or no data in the requested range; check the “details” field if present.
  • 422 unprocessable: wrong date format—always send Y-m-d (e.g., 2026-10-24).

In all code samples above, always check data["success"] when present before dereferencing fields like rates or dates.

Real-world applications with ECB_DEPOSIT

  • Policy dashboards: track ECB_DEPOSIT with /latest and supplement with /fluctuation for recent change statistics.
  • Risk and ALM: pull /timeseries for ECB_DEPOSIT to measure duration of policy stances and to drive scenario engines.
  • Lending and mortgages: estimate simple interest costs via /convert, or compute amortized payments with returned rate values.
  • Macro research: summarize regime changes using /ohlc monthly bars and check turning points versus interbank benchmarks (e.g., EURIBOR_3M) using /timeseries queries.

All these use cases are supported by a single, consistent REST interface at interestratesapi.com using GET requests with api_key authentication.

Putting it together: a minimal end-to-end ECB_DEPOSIT workflow

  1. Discover: call /symbols to confirm ECB_DEPOSIT is available and note frequency=“daily.”
  2. Fetch latest: call /latest for ECB_DEPOSIT and store rate plus effective date.
  3. Backfill: call /historical for decision days you care about, or /timeseries for a range.
  4. Aggregate: call /ohlc with period=monthly for chart-ready bars and summaries.
  5. Compare: call /convert if you need a quick total-interest comparison versus another ECB policy rate.
  6. Monitor: call /fluctuation for rolling windows to power alerts or summaries.

Implementation tips that save time

  • Use a single HTTP client and central retry/caching policy across all endpoints; the interface is consistent.
  • Always log params used and response dates; ECB rates are event-driven—date lineage avoids confusion.
  • Normalize all decimals as percentages on input and store both the raw percentage and decimal fraction if needed.
  • Keep symbol identifiers exact (e.g., “ECB_DEPOSIT”). Do not transform or guess names.
  • Batch symbols where possible (e.g., symbols=ECB_DEPOSIT,ECB_MRO) to reduce calls and coordinate effective dates.

FAQ

Q: What units does ECB_DEPOSIT use in the API?
A: It’s a percentage per annum, returned as a numeric value in the “rates” map (e.g., 2.5 means 2.5% p.a.).

Q: How do I know the effective date of the latest rate?
A: Use the “dates” map when present (e.g., dates[“ECB_DEPOSIT”]). For /historical, the “date” field equals your requested date.

Q: Can I rely on weekends to repeat Friday’s value?
A: The series is daily. Within /timeseries ranges that span non-business days, you should expect the prevailing value to persist across days without new policy actions.

Q: How do I compute a spread to another ECB rate?
A: Request both in one /latest call and subtract: spread = rates[“ECB_DEPOSIT”] − rates[“OTHER_SYMBOL”]. Attach each symbol’s effective date from the “dates” map to your output.

Q: What’s the simplest way to estimate monthly interest for a principal amount?
A: For a simple interest estimate, monthly_interest = principal × (rate/100) ÷ 12. For comparisons at the latest rates, /convert provides total_interest and total_payment directly.

Ship your ECB_DEPOSIT integration now: get your API key and start testing requests in minutes. Register and explore the MCP for endpoint details, then visit interestratesapi.com for more resources.

Keywords
ECB Deposit Facility API ECB_DEPOSIT rate change financial data integration time series analysis historical data retrieval

Ready to get started?

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

Get API Key