# AMF Blacklist Checker - France Financial Scam List (`eurodata-lab/amf-blacklist-checker`) Actor

Bulk-check websites, e-mail domains and firm names against the official AMF blacklists of unauthorised financial firms in France (forex, crypto, impersonation scams). Open data, no proxy.

- **URL**: https://apify.com/eurodata-lab/amf-blacklist-checker.md
- **Developed by:** [Cyril Naets](https://apify.com/eurodata-lab) (community)
- **Categories:** Business, Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $20.00 / 1,000 blacklist checks

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

### What does AMF Blacklist Checker do?

**AMF Blacklist Checker** checks websites, e-mail addresses and firm names in bulk against the **official blacklists of the [Autorité des marchés financiers (AMF)](https://www.amf-france.org/fr/espace-epargnants/proteger-son-epargne/listes-noires-et-mises-en-garde)**, the French financial markets regulator. It tells you, for each item, whether it is on the AMF list of **unauthorised firms and financial scams** (forex, crypto-assets, binary options, fake gold, diamond or wine investments, and impersonation of regulated firms), with the category and the date it was blacklisted.

It works like an **AMF blacklist API**: send a list of domains from your app, a payment flow or a spreadsheet, and get a clean JSON, CSV or Excel answer in seconds. It can also **export the blacklist** itself, filtered by category, date or keyword, for example to receive every week the new scam websites added by the AMF.

The data comes from the AMF's official open dataset on [data.gouv.fr](https://www.data.gouv.fr/datasets/listes-noires-des-entites-non-autorisees-a-proposer-des-produits-ou-services-financiers-en-france) (about 3,500 entries, updated several times a week). The Actor downloads the latest version at every run, so you always check against the current list.

### Why use AMF Blacklist Checker?

- 🏦 **Fraud and compliance teams** at banks, neobanks, payment providers and brokers: screen beneficiaries' websites and e-mail domains before a transfer or an onboarding (KYC/KYB).
- 📢 **Ad networks, affiliate platforms and marketplaces**: block advertisers and sellers that promote unauthorised investment offers in France.
- 🌐 **Hosting providers, domain registrars and e-mail providers**: detect scam websites among your customers.
- 🛡️ **Brand protection**: list every fake website and e-mail domain that impersonates your firm (keyword search on your brand name).
- 📰 **Comparison sites, journalists and researchers**: monitor new scams by category and date.

Key features:

- Accepts **domains, full URLs, e-mail addresses and firm names**, mixed in one list.
- Smart matching: `www.` and `https://` are ignored, subdomains of a listed site are caught, and the AMF's generic addresses (`firstname.lastname@scam-domain.com`) match any address on that domain.
- **No false alarms on big platforms**: an address on gmail.com or a single listed page on calendly.com never flags the whole provider.
- Clear answer: `listed`, `possibleMatch` (needs a human review), `notFound` or `invalidInput` (the item could not be read), plus English category labels.
- Fast and cheap: 1,000 items are checked in a few seconds. No proxy, no login, no browser.
- Runs on the Apify platform: **API access**, **scheduling** (daily or weekly checks), **integrations** (Zapier, Make, n8n, Google Sheets, webhooks) and monitoring.

### What data can AMF Blacklist Checker extract?

**Check items against the blacklist mode** (one row per item you check):

| Field | Type | Description |
|---|---|---|
| `query` | string | The item you checked, as entered |
| `queryType` | string | `domain`, `url`, `email`, `name` or `invalid` |
| `normalizedDomain` | string | Domain that was compared (lower case, without `www.`) |
| `status` | string | `listed`, `possibleMatch`, `notFound` or `invalidInput` |
| `isListed` | boolean | `true` when the status is `listed` |
| `categoryLabels` | array | Categories in English, e.g. `Forex`, `Crypto-assets`, `Impersonation of a regulated firm` |
| `categories` | array | Original AMF category codes (in French) |
| `firstListedDate`, `lastListedDate` | string | Dates (YYYY-MM-DD) on which matching entries were blacklisted |
| `matchCount` | integer | Number of matching blacklist entries |
| `matches` | array | Up to 25 matching entries: `listedEntry`, `listedEntryType`, `domain`, `matchType`, `matchStrength`, `categories`, `categoryLabels`, `listedDate` |
| `errorMessage` | string | Why an item could not be read (only for `invalidInput`) |
| `listUpdatedAt` | string | Version (date and time) of the AMF file used |
| `checkedAt`, `sourceUrl` | string | Run time and link to the official dataset |

**Export the blacklist (with filters) mode** (one row per blacklist entry): `listedEntry`, `listedEntryType` (`domain`, `url`, `email` or `name`), `domain`, `categories`, `categoryLabels`, `listedDate`, `listUpdatedAt`, `checkedAt`, `sourceUrl`. Every row has `recordType` set to `check` or `listEntry`.

What the match types mean:

| `matchType` | Status | Meaning |
|---|---|---|
| `exactDomain` | listed | The domain (or the domain of the e-mail address) is on the list |
| `exactUrl` | listed | The exact listed page |
| `listedPageOnDomain` | listed | A page of this website is on the list |
| `parentDomainListed` | listed | The item is a subdomain of a listed website |
| `exactEmail` | listed | This exact e-mail address is on the list (used for webmail addresses) |
| `exactName` | listed | The firm name is on the list (legal forms such as Ltd or LLC are ignored) |
| `subdomainListed` | possibleMatch | A subdomain of this website is on the list (often a hacked or abused site) |
| `listedPageOnPlatform` | possibleMatch | One page on a shared platform (calendly.com, t.me...) is listed, not the platform |
| `nameMatchesDomain`, `domainMatchesName` | possibleMatch | The firm name and a listed domain are written the same way |
| `partialName` | possibleMatch | The firm name contains, or is contained in, a listed name |

### How to check a website against the AMF blacklist

1. Click **Try for free** (or **Start**) on this page.
2. Keep the mode **Check items against the blacklist**.
3. Paste your websites, e-mail addresses or firm names in **Websites, e-mail addresses or firm names to check**, one per line.
4. Click **Start**. A few seconds later, open the **Output** tab, or download the results as JSON, CSV, Excel or HTML.
5. To automate it, call the Actor from the **API** tab, or create a **schedule** to run it every day.

To get a feed of new scams, choose **Export the blacklist (with filters)**, set **Added to the list since** to `7 days` and schedule the Actor weekly.

### How much does it cost to check the AMF blacklist?

This Actor uses **pay-per-event** pricing: you only pay for the results you get, and the platform usage is included.

| Event | Price | Per 1,000 |
|---|---|---|
| Item checked (`result`), whatever the answer | $0.02 | $20 |
| Blacklist entry exported (`list-entry`) | $0.01 | $10 |
| Actor start (charged automatically by Apify) | $0.00005 | — |

Examples: checking 500 domains costs about **$10**. A weekly feed of new scam websites (typically 10 to 40 entries) costs **$0.10 to $0.40** per week. Unreadable items (`invalidInput`, for example `"a"` or `"bad@"`) and duplicates in your list are **not charged**. Set **Maximum number of results** or a maximum cost per run to keep full control of your budget. You can try the Actor with the monthly credits of the Apify free plan.

### Input

See the **Input** tab for all options. The main fields:

- `mode`: `check` (default) or `list`.
- `queries`: the items to check, in Check items against the blacklist mode.
- `maxResults`: safety cap on the number of results (default 10,000).
- `categories`, `addedSince`, `keyword`: filters for Export the blacklist (with filters) mode. `addedSince` accepts a date (`2026-01-01`) or a period (`7 days`, `2 weeks`, `3 months`). `categories` accepts `impersonation`, `crypto`, `forex`, `binaryOptions`, `alternativeInvestments`, `crowdfunding` and `other`.

Example input (Check items against the blacklist mode):

```json
{
    "mode": "check",
    "queries": [
        "www.diamondxp.com",
        "https://www.x90.com/fr",
        "info@edmondderothschild-private-equity.com",
        "Kuvera",
        "example.com"
    ]
}
```

Example input (Export the blacklist (with filters) mode, brand protection):

```json
{
    "mode": "list",
    "keyword": "rothschild",
    "addedSince": "1 year"
}
```

### Output

You can download the dataset in various formats such as JSON, HTML, CSV or Excel. Example rows from the input above:

```json
[
    {
        "recordType": "check",
        "query": "https://www.x90.com/fr",
        "queryType": "url",
        "normalizedDomain": "x90.com",
        "status": "listed",
        "isListed": true,
        "matchCount": 1,
        "categories": ["Forex"],
        "categoryLabels": ["Forex"],
        "firstListedDate": "2017-06-28",
        "lastListedDate": "2017-06-28",
        "matches": [
            {
                "listedEntry": "www.x90.com/fr",
                "listedEntryType": "domain",
                "domain": "x90.com",
                "matchType": "exactDomain",
                "matchStrength": "listed",
                "categories": ["Forex"],
                "categoryLabels": ["Forex"],
                "listedDate": "2017-06-28"
            }
        ],
        "errorMessage": null,
        "listUpdatedAt": "2026-10-16T06:30:01+00:00",
        "checkedAt": "2026-10-18T18:19:10.442Z",
        "sourceUrl": "https://www.data.gouv.fr/datasets/listes-noires-des-entites-non-autorisees-a-proposer-des-produits-ou-services-financiers-en-france"
    },
    {
        "recordType": "check",
        "query": "example.com",
        "queryType": "domain",
        "normalizedDomain": "example.com",
        "status": "notFound",
        "isListed": false,
        "matchCount": 0,
        "categories": [],
        "categoryLabels": [],
        "firstListedDate": null,
        "lastListedDate": null,
        "matches": [],
        "errorMessage": null,
        "listUpdatedAt": "2026-10-16T06:30:01+00:00",
        "checkedAt": "2026-10-18T18:19:10.442Z",
        "sourceUrl": "https://www.data.gouv.fr/datasets/listes-noires-des-entites-non-autorisees-a-proposer-des-produits-ou-services-financiers-en-france"
    }
]
```

An exported entry (Export the blacklist (with filters) mode). `Usurpation` is the AMF's original French category code for impersonation of a regulated firm, kept as is in `categories`; `categoryLabels` gives the English label:

```json
{
    "recordType": "listEntry",
    "listedEntry": "*@fivearrows-rothschild.com",
    "listedEntryType": "email",
    "domain": "fivearrows-rothschild.com",
    "categories": ["Usurpation"],
    "categoryLabels": ["Impersonation of a regulated firm"],
    "listedDate": "2026-07-10",
    "listUpdatedAt": "2026-10-16T06:30:01+00:00",
    "checkedAt": "2026-10-18T18:21:30.000Z",
    "sourceUrl": "https://www.data.gouv.fr/datasets/listes-noires-des-entites-non-autorisees-a-proposer-des-produits-ou-services-financiers-en-france"
}
```

### Tips

- **Check in bulk**: one run with 1,000 items is as fast as one run with 10 items. Group your checks instead of starting one run per item.
- **Review possible matches by hand**: `possibleMatch` means a related entry exists (same name written as a domain, a listed subdomain...). It is not proof of fraud.
- **Use the API**: the Actor answers in seconds, so you can call it synchronously from your own system.
- **Not on the list does not mean safe**: new scams appear every day. Combine this check with your other controls.

### FAQ

#### Is this the official AMF service?

No. This Actor is an independent tool that reuses the AMF's open data. It is not affiliated with, endorsed by or operated by the Autorité des marchés financiers. The AMF publishes its own search tool on [AMF Protect Epargne](https://protectepargne.amf-france.org/).

#### Where does the data come from, and can I reuse it?

From the dataset "Listes noires des entités non autorisées à proposer des produits ou services financiers en France" (in English: "Blacklists of entities not authorised to offer financial products or services in France"), published by the AMF on data.gouv.fr under the **Licence Ouverte 2.0** (Etalab open licence), which allows commercial reuse with attribution. Each row includes `sourceUrl` and `listUpdatedAt` so you can cite the source and its version.

#### How often is the list updated?

The AMF updates the file several times a week. The Actor downloads the latest file at every run; `listUpdatedAt` tells you which version was used.

#### Is the AMF list complete?

No. The AMF itself states that its blacklists cannot be exhaustive. A `notFound` answer only means that the item is not on the published list. It is not investment advice and not a guarantee that a firm is authorised. To check that a firm is authorised, use the official registers, such as REGAFI (banks, payment and investment firms) and the AMF's lists of authorised firms.

#### Does the output contain personal data?

No. The AMF list contains some e-mail addresses, sometimes with the name of the person whose identity was stolen. The Actor keeps only the domain (`*@scam-domain.com`) and removes names of private individuals from older entries. The list only covers firms and websites. Your own `query` values are returned as you entered them.

> Our Actors are ethical and do not extract any private user data, such as email addresses, gender, or location. They only extract what the user has chosen to share publicly. We therefore believe that our Actors, when used for ethical purposes by Apify users, are safe. However, you should be aware that your results could contain personal data. Personal data is protected by the GDPR in the European Union and by other regulations around the world. You should not scrape personal data unless you have a legitimate reason to do so. If you're unsure whether your reason is legitimate, consult your lawyers.

#### Can I check an exact e-mail address on Gmail or Proton?

Yes. Addresses on free webmail providers are compared as a whole (`exactEmail`), never by their domain, so `anyone@gmail.com` is never flagged just because a scammer once used Gmail.

#### Something looks wrong, or I need another source?

Open the **Issues** tab of this Actor and describe the item and the expected answer. Requests for other regulators' lists are welcome.

# Actor input Schema

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

<b>Check items against the blacklist</b>: returns one result for each website, e-mail address or firm name you enter, saying whether it appears on the AMF blacklists (billed per item checked). <b>Export the blacklist (with filters)</b>: returns the blacklist entries themselves, filtered by category, date and keyword (billed per entry returned).

## `queries` (type: `array`):

One item per line. Accepts domains (example.com), full URLs (https://www.example.com/page), e-mail addresses (only the domain is compared, unless the exact address is listed) and firm names (Example Capital Ltd). Duplicates are checked only once. Used in <b>Check items against the blacklist</b> mode.

## `maxResults` (type: `integer`):

Safety cap on the number of results (items checked, or list entries exported). The run stops once it is reached, so you never pay for more than this.

## `categories` (type: `array`):

Keep only list entries in these categories. Leave empty to keep all categories. Used in <b>Export the blacklist (with filters)</b> mode.

## `addedSince` (type: `string`):

Keep only entries added to the blacklist on or after this date. Enter a date (2026-01-01) or a relative period (7 days, 2 weeks, 3 months). Leave empty to keep all dates. Handy for a daily or weekly feed of new scam websites. Used in <b>Export the blacklist (with filters)</b> mode.

## `keyword` (type: `string`):

Keep only entries whose website, e-mail domain or name contains this keyword, ignoring case, accents, dots and hyphens. Example: a brand name such as 'rothschild' lists all fake websites impersonating it. Leave empty to keep all entries. Used in <b>Export the blacklist (with filters)</b> mode.

## Actor input object example

```json
{
  "mode": "check",
  "queries": [
    "www.diamondxp.com",
    "https://www.x90.com/fr",
    "info@edmondderothschild-private-equity.com",
    "Kuvera",
    "example.com"
  ],
  "maxResults": 10000,
  "categories": [],
  "addedSince": "30 days",
  "keyword": ""
}
```

# Actor output Schema

## `results` (type: `string`):

Dataset with all check results or exported blacklist entries

# 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 = {
    "queries": [
        "www.diamondxp.com",
        "https://www.x90.com/fr",
        "info@edmondderothschild-private-equity.com",
        "Kuvera",
        "example.com"
    ],
    "addedSince": "30 days"
};

// Run the Actor and wait for it to finish
const run = await client.actor("eurodata-lab/amf-blacklist-checker").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 = {
    "queries": [
        "www.diamondxp.com",
        "https://www.x90.com/fr",
        "info@edmondderothschild-private-equity.com",
        "Kuvera",
        "example.com",
    ],
    "addedSince": "30 days",
}

# Run the Actor and wait for it to finish
run = client.actor("eurodata-lab/amf-blacklist-checker").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 '{
  "queries": [
    "www.diamondxp.com",
    "https://www.x90.com/fr",
    "info@edmondderothschild-private-equity.com",
    "Kuvera",
    "example.com"
  ],
  "addedSince": "30 days"
}' |
apify call eurodata-lab/amf-blacklist-checker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,eurodata-lab/amf-blacklist-checker"
        }
    }
}
```

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/GuJinVQHNzbzZxQ79/builds/rjeHmNfPeIxSA2j7h/openapi.json