How to Get the ECB Marginal Lending Facility (ECB_MLF) Rate

How to Get the ECB Marginal Lending Facility (ECB_MLF) Rate

You need a reliable way to fetch the ECB Marginal Lending Facility rate (symbol: ECB_MLF) to drive lending, treasury, or risk models. By the end of this guide, you will query ECB_MLF over HTTPS using only GET requests, interpret the returned fields and effective dates, and plug the rate into calculations like spreads and monthly payments inside your application.

What the ECB_MLF Rate Represents and Why It Matters

The ECB Marginal Lending Facility (ECB_MLF) is the European Central Bank’s overnight lending rate for counterparties on a collateralized basis. It forms the ceiling of the ECB’s interest rate corridor (with the deposit facility as the floor and the main refinancing operations in the middle). For developers and analysts, ECB_MLF is a key policy rate that:

Illustration: How to Get the ECB Marginal Lending Facility (ECB_MLF) Rate
  • Anchors short-term euro funding conditions and the transmission of monetary policy.
  • Offers a policy-ceiling benchmark for pricing treasury, liquidity, and risk buffers.
  • Supports dashboards, loan pricing tools, and macro research workflows where timely policy data matters.

In the Interest Rates API, ECB_MLF is delivered as a daily series under the symbol ECB_MLF. All requests are HTTPS GET calls to https://interestratesapi.com/api/v1/ and authenticate with the api_key query parameter. See the MCP for specification details and additional context.

How the Interest Rates API Works for ECB_MLF

Every endpoint is a GET endpoint under the base URL https://interestratesapi.com/api/v1/ and uses the api_key query parameter (no headers for authentication). The core symbol for this article is ECB_MLF.

  • Authentication: append ?api_key=YOUR_API_KEY to each request.
  • HTTP method: GET only (no POST/PUT/DELETE).
  • Symbol: ECB_MLF (central bank, EUR, daily).
  • Returned values: numeric percentages (e.g., 2.9 means 2.9% per annum).
  • Effective dates: daily ISO dates (YYYY-MM-DD). For weekends/holidays, the latest available business day is typically returned by “latest,” while date-specific queries reflect the availability on that date.

Practical notes for production:

  • Publication cadence: daily (business days) for ECB_MLF as provided by the API; use the dates map to confirm the effective date of each observation.
  • Caching: cache “latest” responses intra-day and invalidate around ECB decision times and end-of-day cycles; use timeseries for backfills.
  • Rate limits: inspect X-RateLimit-Limit, X-RateLimit-Remaining, X-RateLimit-Reset and back off on 429 responses (Retry-After header included).
  • Error handling: handle 401/403 for auth/plan issues, 404 for missing symbols or dates, and 422 for validation errors.

You can explore the platform anytime at https://interestratesapi.com and when you are ready to build, Register to obtain an API key.

Discovering Symbols with /symbols

Use /symbols to list available rate identifiers. Filter by category, base currency, or provider. In practice you would filter base=EUR and category=central_bank to see ECB_MLF and related symbols. Below is an example call and response structure (illustrative listing):

curl -s "https://interestratesapi.com/api/v1/latest?api_key=YOUR_API_KEY&symbols=ECB_MLF"
{
    "success": true,
    "date": "2026-10-10",
    "base": "EUR",
    "rates": {
        "ECB_MLF": 2.9
    },
    "dates": {
        "ECB_MLF": "2026-10-10"
    },
    "currencies": {
        "ECB_MLF": "EUR"
    },
    "base_filter_note": null
}

Key fields:

  • symbol: code you will pass to other endpoints (e.g., ECB_MLF).
  • frequency: data frequency for integration planning.
  • description: summary of the benchmark’s role.

Python example: /symbols

import requests

resp = requests.get(
'https://interestratesapi.com/api/v1/symbols',
params=dict(category='central_bank', base='EUR', api_key='YOUR_API_KEY')
)
symbols = resp.json()
print(symbols.get('success'), symbols.get('count'))
for s in symbols.get('symbols', []):
if s.get('symbol') == 'ECB_MLF':
print('Found:', s)

JavaScript example: /symbols

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();
const ecbMlf = (data.symbols || []).find(s => s.symbol === 'ECB_MLF');
console.log('ECB_MLF found:', !!ecbMlf);

PHP example: /symbols

<?php
$url = 'https://interestratesapi.com/api/v1/symbols?category=central_bank&base=EUR&api_key=YOUR_API_KEY';
$json = file_get_contents($url);
$data = json_decode($json, true);
$found = false;
foreach (($data['symbols'] ?? []) as $s) {
if (($s['symbol'] ?? '') === 'ECB_MLF') { $found = true; break; }
}
echo $found ? "ECB_MLF found\n" : "ECB_MLF not found\n";

Fetch the Latest ECB_MLF with /latest

This is the simplest way to retrieve the current ECB_MLF value. Copy and run the following official sample exactly as shown.

How to read this:

  • rates.ECB_MLF is the rate value as a percentage (2.9 means 2.9% p.a.).
  • date is the top-level timestamp for the snapshot.
  • dates.ECB_MLF is the effective date of the specific symbol’s latest observation.
  • currencies.ECB_MLF indicates the currency context (EUR).

Python example: /latest

import requests

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

JavaScript example: /latest

const response = await fetch(
'https://interestratesapi.com/api/v1/latest?symbols=ECB_MLF&api_key=YOUR_API_KEY'
);
const data = await response.json();
const mlf = data.rates.ECB_MLF;
const effDate = data.dates.ECB_MLF;
console.log('ECB_MLF', mlf, 'on', effDate);

PHP example: /latest

<?php
$url = 'https://interestratesapi.com/api/v1/latest?symbols=ECB_MLF&api_key=YOUR_API_KEY';
$json = file_get_contents($url);
$data = json_decode($json, true);
$mlf = $data['rates']['ECB_MLF'] ?? null;
$eff = $data['dates']['ECB_MLF'] ?? null;
echo "ECB_MLF: {$mlf} on {$eff}\n";

Get ECB_MLF on a Specific Date with /historical

Use /historical to retrieve the ECB_MLF value on a given date (YYYY-MM-DD). For monthly symbols, the last date with data in that month is used, but ECB_MLF is daily.

Key fields:

  • date: the requested date.
  • rates.ECB_MLF: the value for that date if available (numeric percent).
  • currencies.ECB_MLF: currency context.

Note: Values shown in the sample are illustrative as provided in the endpoint reference. Always rely on your live call for production data.

Python example: /historical

import requests

params = dict(date='2025-06-15', symbols='ECB_MLF', api_key='YOUR_API_KEY')
resp = requests.get('https://interestratesapi.com/api/v1/historical', params=params)
data = resp.json()
print(data.get('rates', {}).get('ECB_MLF'), 'for', data.get('date'))

JavaScript example: /historical

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

PHP example: /historical

<?php
$url = 'https://interestratesapi.com/api/v1/historical?date=2025-06-15&symbols=ECB_MLF&api_key=YOUR_API_KEY';
$json = file_get_contents($url);
$data = json_decode($json, true);
echo "ECB_MLF on {$data['date']}: " . ($data['rates']['ECB_MLF'] ?? 'n/a') . "\n";

Build a Historical Curve with /timeseries

Use /timeseries for bulk retrieval between two dates (inclusive). This is ideal for plotting and backtesting.

How to read this:

  • rates.ECB_MLF is a map of date → value for each business day in range.
  • frequencies.ECB_MLF shows the series frequency (“daily”).
  • start_date, end_date confirm the server-validated bounds.

Python example: /timeseries

import requests

params = dict(
start='2025-10-11',
end='2026-10-11',
symbols='ECB_MLF',
api_key='YOUR_API_KEY'
)
resp = requests.get('https://interestratesapi.com/api/v1/timeseries', params=params)
series = resp.json()['rates']['ECB_MLF']
# Convert to sorted (date, value) pairs
curve = sorted(series.items())
print('First points:', curve[:3])

JavaScript example: /timeseries

const url = 'https://interestratesapi.com/api/v1/timeseries?start=2025-10-11&end=2026-10-11&symbols=ECB_MLF&api_key=YOUR_API_KEY';
const response = await fetch(url);
const data = await response.json();
const curve = Object.entries(data.rates.ECB_MLF).sort(([d1],[d2]) => d1.localeCompare(d2));
console.log(curve.slice(0, 3));

PHP example: /timeseries

<?php
$url = 'https://interestratesapi.com/api/v1/timeseries?start=2025-10-11&end=2026-10-11&symbols=ECB_MLF&api_key=YOUR_API_KEY';
$json = file_get_contents($url);
$data = json_decode($json, true);
$series = $data['rates']['ECB_MLF'] ?? [];
ksort($series);
print_r(array_slice($series, 0, 3, true));

Summarize Changes with /fluctuation

/fluctuation computes change statistics over a period: start_value, end_value, absolute change, change_pct, as well as high and low within the window.

Fields to use:

  • change and change_pct: magnitude and percent move across the window.
  • high and low: intraperiod extremes for monitoring bands or alerts.

Python example: /fluctuation

import requests

params = dict(start='2025-10-11', end='2026-10-11', symbols='ECB_MLF', api_key='YOUR_API_KEY')
data = requests.get('https://interestratesapi.com/api/v1/fluctuation', params=params).json()
fl = data['rates']['ECB_MLF']
print('Δ', fl['change'], 'Δ%', fl['change_pct'], 'high', fl['high'], 'low', fl['low'])

JavaScript example: /fluctuation

const url = 'https://interestratesapi.com/api/v1/fluctuation?start=2025-10-11&end=2026-10-11&symbols=ECB_MLF&api_key=YOUR_API_KEY';
const resp = await fetch(url);
const data = await resp.json();
const f = data.rates.ECB_MLF;
console.log(`Change: ${f.change} (${f.change_pct}%), high: ${f.high}, low: ${f.low}`);

PHP example: /fluctuation

<?php
$url = 'https://interestratesapi.com/api/v1/fluctuation?start=2025-10-11&end=2026-10-11&symbols=ECB_MLF&api_key=YOUR_API_KEY';
$data = json_decode(file_get_contents($url), true);
$f = $data['rates']['ECB_MLF'] ?? [];
echo "Change: {$f['change']} ({$f['change_pct']}%) High: {$f['high']} Low: {$f['low']}\n";

Aggregate by Period with /ohlc

/ohlc computes OHLC candles (open, high, low, close) from daily data on the fly. Choose period=weekly|monthly|quarterly, and optional start/end bounds.

Use cases: trend dashboards, volatility screens, and compact time-aggregation for UI components. data_points indicates the count of daily observations contributing to the candle.

Python example: /ohlc

import requests

params = dict(symbols='ECB_MLF', period='monthly', start='2025-10-11', end='2026-10-11', api_key='YOUR_API_KEY')
ohlc = requests.get('https://interestratesapi.com/api/v1/ohlc', params=params).json()
candles = ohlc['rates']['ECB_MLF']
print('First candle:', candles[0])

JavaScript example: /ohlc

const url = 'https://interestratesapi.com/api/v1/ohlc?symbols=ECB_MLF&period=monthly&start=2025-10-11&end=2026-10-11&api_key=YOUR_API_KEY';
const data = await (await fetch(url)).json();
console.log('Sample candle:', data.rates.ECB_MLF[0]);

PHP example: /ohlc

<?php
$url = 'https://interestratesapi.com/api/v1/ohlc?symbols=ECB_MLF&period=monthly&start=2025-10-11&end=2026-10-11&api_key=YOUR_API_KEY';
$data = json_decode(file_get_contents($url), true);
print_r($data['rates']['ECB_MLF'][0] ?? []);

Compare Loan Costs with /convert

/convert compares the total simple-interest cost of a loan priced at the latest rates of two symbols. For ECB integrations, this is helpful to understand the spread and interest impact relative to the main refinancing operations (ECB_MRO) or other benchmarks.

Fields to use:

  • from/to.rate: latest rate per symbol (numeric percent).
  • total_interest, total_payment: simple-interest cost comparison.
  • difference.rate_spread: rate differential (percentage points).

Python example: /convert

import requests

params = dict(from='ECB_MLF', to='ECB_MRO', amount=100000, term_months=12, api_key='YOUR_API_KEY')
data = requests.get('https://interestratesapi.com/api/v1/convert', params=params).json()
spread = data['difference']['rate_spread']
print('Rate spread (pp):', spread)

JavaScript example: /convert

const url = 'https://interestratesapi.com/api/v1/convert?from=ECB_MLF&to=ECB_MRO&amount=100000&term_months=12&api_key=YOUR_API_KEY';
const data = await (await fetch(url)).json();
console.log('Interest saved:', data.difference.interest_saved);

PHP example: /convert

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

How to Use ECB_MLF in Calculations

Once you retrieve ECB_MLF, you can integrate it into pricing and risk analytics without guessing values. A few patterns:

  • Spreads in percentage points: spread_pp = rate_A - rate_B (e.g., ECB_MLF minus ECB_MRO). Use numbers directly as percentages; if you need decimals, divide by 100 once.
  • Monthly payment (amortizing loan): if using ECB_MLF as nominal APR r% with monthly compounding, use:
    r_month = (r / 100) / 12
    payment = P * r_month / (1 - (1 + r_month)^(-n))
    Where P is principal and n is number of months. Compute r from the API’s rates.ECB_MLF field.
  • Interest accrual (simple interest): interest = P * (r / 100) * (days / 360 or 365), depending on your convention.

Date handling tips:

  • Use dates.ECB_MLF from /latest to confirm the precise effective date. If your operations skip weekends and ECB holidays, cache that figure until a new business-day update appears.
  • For backfills or point-in-time analytics, prefer /timeseries over a loop of /historical calls.

Operational reliability:

  • Caching: cache immutable past dates aggressively; set a short TTL for “latest.”
  • Retries: implement exponential backoff on transient network failures and 429 responses.
  • Validation: guard against missing symbols or empty ranges (404) and date format errors (422).

Explore more on https://interestratesapi.com and consult the MCP for specification details.

Real-World Use Cases for ECB_MLF Data

  • Interest rate dashboards: display ECB_MLF alongside ECB_MRO and ESTR for a complete policy corridor view.
  • Loan pricing: compute policy-linked add-ons or cushions based on ECB_MLF spreads.
  • Treasury and ALM: monitor directional changes using /fluctuation and aggregate trends via /ohlc for policy cycles.
  • Macro research and risk: run scenario analyses using /timeseries to backtest sensitivities to policy shifts.
  • Fintech apps: power notifications (“ECB_MLF changed by X bps this month”) using /fluctuation outputs.

Endpoint Reference Recap

  • /symbols: discover ECB_MLF and related identifiers (filters: base, category, provider).
  • /latest: fetch current ECB_MLF with effective date and currency context.
  • /historical: retrieve ECB_MLF for a specific date.
  • /timeseries: pull date-indexed observations across a range.
  • /fluctuation: compute change, change_pct, high, low between two dates.
  • /ohlc: generate periodized OHLC candles for charting.
  • /convert: compare total simple-interest cost across symbols (e.g., ECB_MLF vs ECB_MRO).

All calls are GET, and every URL includes api_key=YOUR_API_KEY in the query string. Base URL is https://interestratesapi.com/api/v1/.

FAQ

Q: Are ECB_MLF values returned as percentages or decimals?
A: As percentages. For example, 2.9 represents 2.9% per annum. Convert to a decimal by dividing by 100 when needed.

Q: How do I know the effective date for ECB_MLF?
A: Use the dates map in the response (e.g., dates.ECB_MLF in /latest) to confirm the specific effective date for that symbol.

Q: How should I handle weekends and holidays?
A: Cache the latest available business-day value. For plotting or statistical work, use /timeseries, which only includes days with data.

Q: What errors should my integration handle?
A: Common ones are 401 (missing/invalid api_key), 403 (no active plan), 404 (no symbol or data for requested date/range), 422 (validation, e.g., bad date), and 429 (quota exhausted). Respect Retry-After and X-RateLimit-* headers.

Q: Can I compute spreads to other ECB rates?
A: Yes. Fetch both series (e.g., ECB_MLF and ECB_MRO) via /latest or /timeseries and subtract one percentage from the other to get spreads in percentage points.

Ship your ECB_MLF integration now. Generate your key with a single step: Register. For data model and endpoint specifics, refer to the MCP.

Keywords
ECB Marginal Lending Facility ECB_MLF API fetch ECB_MLF rate API development guide query ECB_MLF over HTTPS

Ready to get started?

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

Get API Key