# EU Financial Entities: MiCA, PSD2 & Insurers Register (`rastriq/eu-financial-entities-register`) Actor

- **URL**: https://apify.com/rastriq/eu-financial-entities-register.md
- **Developed by:** [Rastriq — Structured data from the world](https://apify.com/rastriq) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.10 / 1,000 entity returneds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## EU Financial Entities Register - MiCA, PSD2 and Insurers

**EU Financial Entities Register** puts three official EU registers in one clean table: **MiCA** crypto-asset service providers (CASPs), token issuers, white papers and non-compliant entities (**ESMA**), **payment and e-money institutions** under PSD2 (**EBA**) and **insurance undertakings** (**EIOPA**). One row per entity with LEI, home country, competent authority, services, **passporting countries**, authorisation dates, status and a **cross-register LEI match** (`other_registers`); a `delta` mode returns only what changed - new licences, withdrawals, new passports.

### What data you get

About **11,900 entities** (counts of 24 Oct 2026):

| Register | Source | What it covers | Entities |
|---|---|---|---|
| `esma_mica` | ESMA interim MiCA register | Crypto-asset service providers, EMT and ART token issuers, white-paper offerors, non-compliant entities | ~1,670 |
| `eba_psd2` | EBA register of payment and e-money institutions (PSD2) | Payment institutions, e-money institutions, exempted institutions, account information service providers, branches (agents excluded) | ~6,640 |
| `eiopa` | EIOPA register of insurance undertakings | Insurance undertakings: domestic, third-country branches and cross-border (passported) activity | ~3,570 |

| Field | Description |
|---|---|
| `register`, `register_family` | Entity type (e.g. `mica_casp`, `eba_emoney_institution`, `eiopa_insurance_undertaking`) and source register |
| `entity_key` | Stable key for joins and change tracking |
| `name`, `commercial_name`, `national_id` | Legal name, trade name and national reference code (EBA, EIOPA) |
| `lei`, `lei_source` | LEI as published (`register`) or matched by name and country from another register (`name_match`) |
| `home_country`, `competent_authority` | Home Member State and the authority that authorised the entity |
| `address`, `city`, `postal_code`, `website` | Address data as published (city and postal code: EBA, EIOPA) |
| `authorisation_date`, `authorisation_end_date`, `status` | `authorised`, `withdrawn`, `notified` (white papers) or `warning` (non-compliant) |
| `services`, `service_labels` | MiCA services, PSD2 service codes with labels (`PS_03C` = Credit transfers), or insurance status (`domestic`, `third_country_branch`) |
| `passporting_countries`, `branch_countries` | Where the entity operates outside its home country |
| `other_registers` | Other registers in which the same LEI appears |
| `source_status`, `source_updated_at`, `quality_flags` | Freshness of the source, its own update time and data-quality flags |
| `first_seen_at`, `last_seen_at`, `change_type`, `changed_fields`, `previous_values` | Delta tracking |

### Why use it

| | |
|---|---|
| 🧩 **Three registers, one schema** | ESMA CSVs, the EBA 220 MB JSON and the EIOPA export are normalised into the same fields. |
| 🔗 **LEI crosswalk** | `other_registers` shows when the same LEI appears in another register (e.g. a CASP that is also an e-money institution). EBA entries (no LEI in the source) get an LEI when ESMA publishes the same name and country (`lei_source = name_match`). |
| 🌍 **Passporting** | `passporting_countries` and `branch_countries`: filter "who can operate in Spain". |
| 🔔 **Change feed** | `delta` returns only new, changed (`changed_fields`, `previous_values`) and removed entities; unchanged entities are free. |
| 🧹 **Clean** | ISO dates, validated LEIs, service labels, `quality_flags`. Rows are flagged, never dropped. |

### Snapshot vs delta: what each mode returns and charges

| Mode | Kind | What you get | What is charged |
|---|---|---|---|
| **Snapshot** | full list in scope | Every entity that matches your filters, on every run | `entity-record` per row |
| **Delta** (default) | changes only | 1st run: everything in scope as `baseline`. Later runs: only `new`, `changed` and `removed` entities since your last run | 1st run: `entity-record` per row. Later runs: `entity-change` per changed row only. **Unchanged entities are never charged**; if no register changed, the run returns nothing and costs only the start fee |

Each combination of filters keeps its own change stream (in a named key-value store, `eu-fin-entities-state`, in your Apify account), so a filtered run never consumes the changes another run should see.

### Use cases

1. **KYB / onboarding** - banks, fintechs, marketplaces and payment partners: check that a counterparty holds a MiCA, PSD2 or insurance authorisation and in which countries.
2. **Compliance monitoring** - schedule `delta` weekly to catch withdrawals, new warnings (`mica_non_compliant`) and changes for your counterparties.
3. **B2B sales and partnerships** - RegTech, KYC, custody, core banking and payment-processing vendors: every newly authorised CASP, EMI or insurer, by country.
4. **Market intelligence** - count CASPs by home country, services and passporting; map the EU payment, e-money and insurance landscape.
5. **Data enrichment** - join to your CRM by `lei` or `national_id`.

### How to use

1. Keep the pre-filled values and click **Start**: 10 MiCA crypto-asset service providers that can operate in Spain, about $0.05.
2. Choose **Registers** (all three by default), **Entity types**, **Home countries**, **Operating in** or **Name contains** to change the scope. Clear the filters and set **Max rows** to 0 to get everything (~11,900 entities).
3. For monitoring, switch **Mode** to **Delta** and add a weekly schedule.

### Input

| Field | Type | Description |
|---|---|---|
| `mode` | enum | `delta` (default when empty) or `snapshot` |
| `registers` | array | `esma_mica`, `eba_psd2`, `eiopa`. Default: all three |
| `entityTypes` | array | e.g. `mica_casp`, `eba_emoney_institution`, `eiopa_insurance_undertaking` |
| `countries` | array | Home Member State codes |
| `passportingTo` | array | Countries where the entity operates (passport or branch) |
| `nameContains` | string | Text search in the names |
| `includeWithdrawn` | boolean | Include ended authorisations (default on) |
| `maxItems` | integer | Row limit and spending cap (pre-filled 10; 0 = none) |
| `stateKey` | string | Name of an independent change-tracking stream |
| `proxyConfiguration` | object | Fallback proxy for ESMA and EIOPA (default: Apify Residential, Germany) |

```json
{ "mode": "delta", "registers": ["eba_psd2"], "entityTypes": ["eba_emoney_institution"], "countries": ["LT", "MT"] }
```

#### Proxy (`proxyConfiguration`)

ESMA and EIOPA answer HTTP 403 to cloud (datacenter) IP addresses. For each of them the Actor sends the request **directly first** and, only if it is refused, repeats the same request through the proxy you configure here. The default is the **Apify Residential proxy in Germany** (EU), which needs no setup. The EBA register is always fetched directly.

- **Cost:** proxy traffic is included in the Actor's price; you only pay the events below. The EIOPA register is a large export (about 58 MB) that has to go through the residential proxy, so a run that needs it is charged one `insurance-register-download` event ($0.10) once per run. It is only downloaded when it can contribute rows: leave `eiopa` out of **Registers**, or filter **Entity types** to MiCA / PSD2 types, and it is skipped (and not charged). If your spending limit does not cover that event, the insurance register is skipped and reported in `RUN_SUMMARY`.
- **Different country or group:** choose another proxy in the field (for example another EU country) if you need to.
- **No proxy:** if you disable the proxy, ESMA and EIOPA cannot be fetched; the run finishes as `completed_partial` and tells you in `RUN_SUMMARY` (`source.blocked`).

### Output example

Real MiCA row (run of 24 Oct 2026, lists shortened here):

```json
{
  "entity_key": "esma:CASPS:AT:254900ERDZ4CZ5IF7P56",
  "register": "mica_casp",
  "register_family": "esma_mica",
  "lei": "254900ERDZ4CZ5IF7P56",
  "lei_source": "register",
  "name": "WB-Shields Innovations GmbH",
  "commercial_name": "WhiteBIT EU",
  "national_id": null,
  "home_country": "AT",
  "competent_authority": "Austrian Financial Market Authority (FMA)",
  "address": "Stella-Klein-Löw-Weg 8 1020 Vienna, Austria",
  "city": null,
  "postal_code": null,
  "website": "https://whitebit.eu",
  "authorisation_date": "2026-06-18",
  "authorisation_end_date": null,
  "status": "authorised",
  "services": [
    "a. providing custody and administration of crypto-assets on behalf of clients",
    "c. exchange of crypto-assets for funds"
  ],
  "service_labels": [
    "a. providing custody and administration of crypto-assets on behalf of clients",
    "c. exchange of crypto-assets for funds"
  ],
  "passporting_countries": [
    "AT",
    "BE",
    "BG",
    "CY",
    "CZ",
    "DE",
    "..."
  ],
  "branch_countries": [],
  "white_paper_url": null,
  "notes": null,
  "is_name_redacted": false,
  "quality_flags": [],
  "other_registers": [],
  "source": "ESMA interim MiCA register",
  "source_url": "https://www.esma.europa.eu/esmas-activities/digital-finance-and-innovation/markets-crypto-assets-regulation-mica",
  "source_updated_at": "Thu, 22 Oct 2026 15:16:00 GMT",
  "source_status": "current",
  "first_seen_at": "2026-10-24T21:11:33Z",
  "last_seen_at": "2026-10-24T21:11:33Z",
  "detected_at": "2026-10-24T21:11:33Z",
  "change_type": "baseline",
  "changed_fields": [],
  "previous_values": null
}
```

Real insurance row (EIOPA):

```json
{
  "entity_key": "eiopa:AT:116",
  "register": "eiopa_insurance_undertaking",
  "register_family": "eiopa",
  "lei": "529900B0OFX1G2LS5L25",
  "lei_source": "register",
  "name": "UNIQA Österreich Versicherungen AG",
  "commercial_name": "UNIQA Oesterreich Versicherungen AG",
  "national_id": "116",
  "home_country": "AT",
  "competent_authority": "Finanzmarktaufsicht (FMA)",
  "address": "Untere Donaustraße 21",
  "city": "Wien",
  "postal_code": "1029",
  "website": "www.uniqa.at",
  "authorisation_date": "1991-01-01",
  "authorisation_end_date": null,
  "status": "authorised",
  "services": [
    "domestic"
  ],
  "service_labels": [
    "domestic"
  ],
  "passporting_countries": [
    "BE",
    "BG",
    "CY",
    "CZ",
    "DE",
    "DK",
    "..."
  ],
  "branch_countries": [],
  "white_paper_url": null,
  "notes": null,
  "is_name_redacted": false,
  "quality_flags": [],
  "other_registers": [],
  "source": "EIOPA Register of insurance undertakings",
  "source_url": "https://register.eiopa.europa.eu/registers/register-of-insurance-undertakings",
  "source_updated_at": "2026-10-24T21:12:37Z",
  "source_status": "current",
  "first_seen_at": "2026-10-24T21:12:09Z",
  "last_seen_at": "2026-10-24T21:12:09Z",
  "detected_at": "2026-10-24T21:12:09Z",
  "change_type": "baseline",
  "changed_fields": [],
  "previous_values": null
}
```

#### Key fields

| Field | Description |
|---|---|
| `register`, `register_family` | Entity type and source register |
| `lei`, `lei_source` | LEI as published (`register`) or matched by name and country (`name_match`) |
| `status` | `authorised`, `withdrawn`, `notified` (white papers), `warning` (non-compliant) |
| `services`, `service_labels` | MiCA services, PSD2 service codes (`PS_03C` -> Credit transfers) or insurance status |
| `passporting_countries`, `branch_countries` | Where the entity operates outside its home country |
| `other_registers` | Other registers in which the same LEI appears (only registers fetched in the run) |
| `source_status` | `current`, or `stale_source_blocked` if the entity's register could not be fetched in this run and the last known data of your stream was kept |
| `quality_flags` | `invalid_lei`, `lei_inferred_by_name`, `multiple_names_in_source`, `no_legal_form_in_name`, `possible_natural_person_redacted`, `no_home_record` (EIOPA: cross-border activity without a home record), `duplicate_in_source`. Rows are flagged, never dropped |

### Personal data

PSD2 **agents** (about 325,000 entries, many of them individuals) are not included. Some registers also admit natural persons (exempted payment institutions, excluded activities, white-paper offerors, warnings). In those registers, an entry without LEI whose name looks like a person's has its name, address and national ID set to `null` and is flagged `possible_natural_person_redacted`. Authorised payment and e-money institutions, CASPs, issuers and insurers are legal persons by law and are only flagged when the name shows no legal form.

### Pricing

Pay per event. Tier discounts: Silver -15 %, Gold and above -30 % (Free plan +15 %).

| Event | Price (Bronze) |
|---|---|
| `entity-record` - one entity in a snapshot or baseline | $3.00 / 1,000 |
| `entity-change` - one new / changed / removed entity in delta | $5.00 / 1,000 |
| `insurance-register-download` - EIOPA register fetched in this run (only when insurers are requested) | $0.10 per run |
| Actor start | $0.01 per run |

Only returned rows are billed; unchanged entities in delta are free, and a delta run where no register changed costs only the start fee. The pre-filled example (10 MiCA CASPs) costs about $0.04; 200 MiCA CASPs operating in Spain about $0.61; all registers (~11,900 entities) about $36.10 (including the one-time insurance register download). A scheduled delta run that includes insurers costs $0.11 when nothing changed. **Max rows** caps what a run can bill.

### Sources, licences and limits

- **ESMA** interim MiCA register ([page](https://www.esma.europa.eu/esmas-activities/digital-finance-and-innovation/markets-crypto-assets-regulation-mica)). ESMA plans to move the interim CSV register into its IT systems; the Actor stops with `source_format_changed` rather than returning wrong data if the files change.
- **EBA** Register of payment and electronic money institutions under PSD2 ([register](https://euclid.eba.europa.eu/register/pir/search)). The EBA states the register "has no legal significance and confers no rights in law"; national registers prevail. EBA material may be reproduced provided the source is acknowledged.
- **EIOPA** Register of insurance undertakings ([register](https://register.eiopa.europa.eu/registers/register-of-insurance-undertakings)). Reproduction is authorised provided EIOPA is acknowledged as the source; national registers prevail.
- If a register still refuses the request after the proxy retry (or the proxy is disabled), the run continues with the other registers, keeps the last known data of that register in your stream (no false removals), marks its rows `source_status: stale_source_blocked` and reports it in `RUN_SUMMARY` (`status: completed_partial`, `source.blocked`). If all registers refuse, the run fails.
- The Actor downloads public register files only: no login, no captcha solving. Not affiliated with or endorsed by ESMA, the EBA or EIOPA. Not legal advice: for a binding check use the competent national authority's register.

### FAQ

**Which registers are covered?** ESMA (MiCA), EBA (PSD2 payment and e-money institutions) and EIOPA (insurance undertakings). The default is all three.

**How often do the sources change?** ESMA republishes the MiCA CSVs regularly (weekly in practice), the EBA file is regenerated several times a day and EIOPA refreshes its register regularly. A weekly delta schedule is plenty for monitoring.

**Do I need to set up a proxy?** No. The default (Apify Residential, Germany) works out of the box and is only used when ESMA or EIOPA refuse the direct request. See *Proxy* for the cost.

**Is it legal to use this data?** The registers are public by law and the Actor only downloads the public files. Reproduction is allowed with attribution (see *Sources*); entries that look like private individuals are redacted.

**Why do some EBA rows have an LEI?** The EBA does not publish LEIs; when ESMA lists exactly the same name in the same country, the Actor adds it and marks `lei_source = name_match`.

**Why is `other_registers` empty?** The cross-register match only considers registers fetched in that run (for example, not EIOPA if you filtered to MiCA types).

**Are UK entities included?** Only if a register still lists them; the EBA is removing UK entries.

Built by **Rastriq** - reliable data from official registers. Questions or feature requests: use the Actor's Issues tab.

# Changelog

This Actor's version history is a separate document: https://apify.com/rastriq/eu-financial-entities-register/changelog.md

# Actor input Schema

## `mode` (type: `string`):

<b>Delta</b> (default when empty): the first run returns everything in scope as <code>baseline</code>; later runs return only new, changed and removed entities since your last run, and unchanged entities are free.<br><b>Snapshot</b>: everything in scope on every run.

## `registers` (type: `array`):

Which registers to return. Empty = all three. ESMA = MiCA crypto-assets, EBA = PSD2 payment and e-money institutions, EIOPA = insurance undertakings. The EIOPA register is only downloaded when it can contribute rows (selected here and not excluded by <i>Entity types</i>), because its download is charged as one $0.10 event per run.

## `entityTypes` (type: `array`):

Narrow down within the registers, e.g. <code>mica_casp</code> for crypto-asset service providers or <code>eba_emoney_institution</code> for e-money institutions. Empty = all types. An entity type belongs to one register, so choosing only MiCA types skips the EIOPA download.

## `countries` (type: `array`):

Keep only entities whose home Member State is one of these 2-letter codes, e.g. <code>LU</code>, <code>MT</code>, <code>LT</code>. Empty = all.

## `passportingTo` (type: `array`):

Keep only entities that passport services into, or have a branch in, one of these countries (2-letter codes), e.g. <code>ES</code> for entities that can operate in Spain. Empty = no filter.

## `nameContains` (type: `string`):

Case-insensitive text search in the legal and commercial name, e.g. <code>bank</code>. Empty = all.

## `includeWithdrawn` (type: `boolean`):

Entities whose authorisation has ended (<code>status = withdrawn</code>). The EBA register keeps many of them; ESMA and EIOPA list few.

## `maxItems` (type: `integer`):

Stop after this many rows (0 = no limit). Every row is billed, so this is also your spending cap. Pre-filled with 10; set 0 for everything in scope (up to about 11,900 entities).

## `stateKey` (type: `string`):

Optional name of the change-tracking stream (e.g. <code>kyb-watchlist</code>). Each combination of filters already has its own stream; set a name to keep one stream when you edit the filters. Delta mode only.

## `proxyConfiguration` (type: `object`):

ESMA and EIOPA reject direct requests from cloud IPs. The Actor always tries the source directly first and, only when it is refused, repeats the request through this proxy. Default: Apify Residential, Germany. Proxy traffic is included in the Actor price; only the EIOPA download (about 58 MB) is charged as one <code>insurance-register-download</code> event ($0.10) per run that needs it. The EBA register is always fetched directly. If you turn the proxy off, ESMA and EIOPA rows are not available (the run finishes as <code>completed_partial</code>).

## Actor input object example

```json
{
  "mode": "snapshot",
  "registers": [
    "esma_mica",
    "eba_psd2",
    "eiopa"
  ],
  "entityTypes": [
    "mica_casp"
  ],
  "passportingTo": [
    "ES"
  ],
  "includeWithdrawn": true,
  "maxItems": 10,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "DE"
  }
}
```

# Actor output Schema

## `entities` (type: `string`):

No description

## `runSummary` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "mode": "snapshot",
    "registers": [
        "esma_mica",
        "eba_psd2",
        "eiopa"
    ],
    "entityTypes": [
        "mica_casp"
    ],
    "passportingTo": [
        "ES"
    ],
    "maxItems": 10,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "DE"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("rastriq/eu-financial-entities-register").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "mode": "snapshot",
    "registers": [
        "esma_mica",
        "eba_psd2",
        "eiopa",
    ],
    "entityTypes": ["mica_casp"],
    "passportingTo": ["ES"],
    "maxItems": 10,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "DE",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("rastriq/eu-financial-entities-register").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "mode": "snapshot",
  "registers": [
    "esma_mica",
    "eba_psd2",
    "eiopa"
  ],
  "entityTypes": [
    "mica_casp"
  ],
  "passportingTo": [
    "ES"
  ],
  "maxItems": 10,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "DE"
  }
}' |
apify call rastriq/eu-financial-entities-register --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,rastriq/eu-financial-entities-register"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/OLyDfQpa9DsrUWwdQ/builds/WLvPCmyTUOWC0Aiev/openapi.json