Getting started with the p3dh-data endpoint
The p3dh endpoint gives you access to the Pillar 3 disclosures of hundreds of European banks, as published on the EBA's Pillar 3 Data Hub. These are the raw figures that the /v1/metrics/ endpoint computes its ratios from. This guide shows you how to access the underlying data.
Reach for /v1/p3dh-data/ instead of /v1/metrics/ when you're rolling your own ratio, running analytics that need a nominal amount rather than a computed metric, or loading the full dataset into a data warehouse for analysts across your organization to build on. If you're looking for a specific ratio that relies on a specific definition, please reach out to have it added to the /v1/metrics/ endpoint.
Dimensions
Every data point sits at the intersection of five things: a bank, a reference period, a table, a row, and a column.
- Table: an EBA disclosure template, identified by
table_code, e.g.K 61.00(EU KM1: Key metrics) orK 71.00(EU LR2: Leverage ratio common disclosure). Spaces are optional:K61.00resolves to the same table asK 61.00. - Row: a line item within the table, identified by
row_code(e.g.0320) with a human-readablerow_label(e.g. *"17. Liquidity coverage ratio (%)"*). - Column: a further breakdown within the row, identified by
col_codewith acol_label(e.g. *"a. T"* for the current period, *"b. T-1"* for the prior one). - Bank: the reporting institution, identified by
entity_lei. LEIs in this dataset carry a.CONsuffix for consolidated group entities. Use that form, not the bare 20-character LEI an external registry returns. Look one up in the banks dictionary rather than guessing at it. - Reference period: the reporting date, as
YYYY-MM-DD.
Example
Let's say you're looking for Deutsche Bank's key metrics template:
url = API_URL + "v1/p3dh-data/"
data = requests.get(
url=url,
headers={"X-API-Key": API_KEY},
params={"entity_name": "DEUTSCHE BANK AKTIENGESELLSCHAFT", "table_code": "K61.00"},
)
data.json()Each record in the response is one cell:
{
"dp_id": "dp143076",
"entity_lei": "7LTWFZYICNSX8D621K86.CON",
"entity_name": "DEUTSCHE BANK AKTIENGESELLSCHAFT",
"country": "Germany",
"ref_period": "2025-12-31",
"base_currency": "EUR",
"table_code": "K 61.00",
"table_name": "EU KM1 - Key metrics template",
"row_code": "0320",
"row_label": "17. Liquidity coverage ratio (%)",
"col_code": "0010",
"col_label": "a. T",
"value": 1.3722,
"string_value": None,
"value_type": "numeric",
"unit": None
}value holds numeric cells; string_value holds text cells (narrative disclosures, mostly). Check value_type before reading either. Note that exactly one of the two is populated per row, never both.
Other dimensions
You can also filter on entity_type (Banking Group, CRD Credit Institution, PILLAR3 Sub Group), institution_type (Large highest EEA, Other highest EEA, Large subsidiaries), and submission_date, useful if a bank has resubmitted a period and you want a specific vintage rather than the latest one. entity_lei, country, table_code, and ref_period all accept repeated query parameters, so you can compare several banks or periods in one call:
A bank can resubmit a disclosure module, and each resubmission gets its own row rather than overwriting the prior one. only_latest defaults to true: for each individual cell, only the row from its most-recently-submitted module is returned. Pass only_latest=false to get every submission's rows back instead, and only_latest is ignored when submission_date is set, since pinning an exact date is already more specific than "the latest one."
url = API_URL + "v1/p3dh-data/"
data = requests.get(
url=url,
headers={"X-API-Key": API_KEY},
params={
"entity_lei": ["7LTWFZYICNSX8D621K86.CON", "549300NYKK9MWM7GGW15.CON"],
"table_code": "K71.00",
"ref_period": ["2025-09-30", "2025-12-31"],
},
)Filtering by axis
A few templates can't be a plain row-by-column grid because the same cell repeats once per country, sector or exposure class (their row_code is * and row_label is null). The only thing that tells those rows apart is axis_value, for example qOOR=eba_GA:FR (France) in the geographical breakdown K 83.01.c/.d, or GPR=eba_GA:DE|NAC=eba_NC:I (Germany, NACE sector I) in the climate templates K 45.00.a/.b. It's a |-joined list of DIM=member parts, and it is returned as reported, not resolved to a label.
Use axis_dim to name the dimension and axis_member to pick one or more members (repeat the parameter to combine them):
url = API_URL + "v1/p3dh-data/"
data = requests.get(
url=url,
headers={"X-API-Key": API_KEY},
params={
"table_code": "K 83.01.c",
"col_code": "0010", # gross carrying amount
"ref_period": "2025-12-31",
"axis_dim": "qOOR",
"axis_member": ["FR", "DE"],
},
)A few things to know:
axis_memberaccepts the bare code (FR) or the full raw member (eba_GA:FR), case-insensitively, and always matches the *whole* member, soFRnever matchesFRA. Free-text members, such asGPR=CYPRUS, must be given in full.axis_memberneedsaxis_dim; without it the API returns422.axis_dimon its own keeps only the rows that carry that dimension.- Always combine the filter with
table_code(and ideallyref_period). It narrows results but isn't indexed, so on its own it scans every axis row. - Dimensions differ by template:
qOOR,RIOandGPRare countries in different templates,NACis a NACE sector andqEEAan IRB exposure class. Fetch one row without the filter first to see which dimension a template uses. - Amounts are in each bank's
base_currency, and a banking group's figures include its subsidiaries, so don't sum across banks without checking both.
Finding the table, row, and column you need
If you don't already know the table_code/row_code/col_code you're after, don't guess. Search for it. /v1/tables/ returns the full schema map (one record per unique table/row/column combination) and supports partial matching on labels:
url = API_URL + "v1/tables/"
data = requests.get(
url=url,
headers={"X-API-Key": API_KEY},
params={"row_label": "non-performing"},
)Or, if you don't know the bank or the template by name, /v1/search-p3dh/ searches both at once with a single keyword:
url = API_URL + "v1/search-p3dh/"
data = requests.get(
url=url,
headers={"X-API-Key": API_KEY},
params={"keyword": "leverage"},
)Authentication
All endpoints require authentication through an API key. You need to include it in the X-API-Key header, like this:
data = requests.get(
url=url,
headers={"X-API-Key": API_KEY},
params={"metric_name": "cet1_ratio"},
)Caps, pagination and offsets
Results default to limit=1000, capped at your key's per-request maximum number of rows. Page through a larger result set with offset.
limit and offset are query parameters, so they go in params, next to your filters. Only the API key goes in headers. The API doesn't read limit or offset from a header. If you put them there, you won't get an error, just the default first page (limit=1000, offset=0) on every call. offset is the number of rows to skip, not a page number: the second page of 1,000 rows starts at offset=1000, not offset=1.
url = API_URL + "v1/p3dh-data/"
data = requests.get(
url=url,
headers={"X-API-Key": API_KEY}, # the API key only
params={
"table_code": "K61.00",
"limit": 1000, # rows per page
"offset": 1000, # rows to skip: this is the second page
},
)Every response carries pagination state in its headers, so you don't have to guess whether there's more:
X-Result-Count: records in this response.X-Has-More:trueif another page exists.X-Limit/X-Offset: the effective values applied (limit may be lower than you asked for, if your key caps it).X-Plan-Capped:truewhen your key's cap, not your ownlimit, determined the page size.
To fetch the whole result, loop until X-Has-More is false. Advance offset by X-Limit, not by the limit you asked for. If your key clamps a limit=5000 down to 1,000 and you advance by 5,000, you skip 4,000 rows each time and nothing tells you:
url = API_URL + "v1/p3dh-data/"
headers = {"X-API-Key": API_KEY}
params = {"table_code": "K61.00", "limit": 1000, "offset": 0}
rows = []
while True:
response = requests.get(url=url, headers=headers, params=params)
response.raise_for_status()
rows.extend(response.json())
if response.headers["X-Has-More"] != "true":
break
params["offset"] += int(response.headers["X-Limit"])From raw cells to your own metric
Data points come back in long format: one row per cell. If you want to compute your own ratio, say a simple CET1 ratio from CET1 capital and total risk exposure, pull both rows and pivot to wide format in pandas:
import pandas as pd
url = API_URL + "v1/p3dh-data/"
data = requests.get(
url=url,
headers={"X-API-Key": API_KEY},
params={
"entity_lei": "7LTWFZYICNSX8D621K86.CON", # Deutsche Bank AG
"table_code": "K61.00",
"ref_period": "2025-06-30",
"col_code": "0010", # "a. T": current-period column only, specific to LCR disclosures
},
)
df = pd.DataFrame(data.json())
wide = df.pivot_table(
index=["entity_name", "ref_period"],
columns="row_label",
values="value",
)wide now has one row per bank/period and one column per line item, ready to combine into your own formula, or to compare against the equivalent pre-computed metric from /v1/metrics/ as a sanity check.