# Sanctions Screening: EU, UK, OFAC & France Lists (`datacraft-studio/sanctions-screening-eu-uk-us`) Actor

Screen people and companies against the official EU, UK, US OFAC (SDN and non-SDN) and French asset-freeze lists, downloaded fresh on every run. Fuzzy, accent and Cyrillic-aware matching, birth-year check, programs and source links. For KYC, KYB and supplier checks.

- **URL**: https://apify.com/datacraft-studio/sanctions-screening-eu-uk-us.md
- **Developed by:** [Yahya Nouali](https://apify.com/datacraft-studio) (community)
- **Categories:** Business, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 name screeneds

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

## Sanctions Screening: EU, UK, OFAC & France Lists

Screen people and companies against four **official government sanctions lists** in one run:

| Code | List | Publisher | Licence |
| --- | --- | --- | --- |
| `EU` | EU consolidated list of persons, groups and entities subject to financial sanctions | European Commission (FISMA) | Free reuse under Commission Decision 2011/833/EU |
| `UK` | UK Sanctions List | Foreign, Commonwealth & Development Office | Open Government Licence v3.0 |
| `OFAC` | Specially Designated Nationals (SDN) list and the consolidated non-SDN lists | US Treasury, OFAC | US Government work, public domain |
| `FR` | Registre national des gels (French asset-freeze registry) | Direction générale du Trésor | Licence Ouverte 2.0 |

The lists are **downloaded fresh from the publishers on every run**. There is no cached copy that can go stale and no third-party aggregator in between.

Use it for KYC and KYB onboarding, supplier and partner due diligence, periodic re-screening of a customer base, or one-off checks before a payment.

### What you get

For each name you get one row:

- `status`: `match` (score of 0.95 or more), `potential_match` (at or above your threshold) or `no_match`.
- `topScore`, `matchCount` and `matchedLists`.
- `matches`: the best hits. Each hit has the list, the list's own id, the matched name and primary name, aliases, score, birth-date check, subject type, sanctions programmes, birth dates, nationalities, identifiers, designation date and a **link to the official record**.
- `listsScreened` and `listsFailed`, so every result says exactly what it was checked against.

The run ends with a `run_summary` row. It gives the version or publication date of each list, its number of entries, its licence and the price applied.

### Matching

- Names are folded: case, accents, punctuation and word order are ignored, and Cyrillic is transliterated. `Владимир Путин`, `PUTIN, Vladimir` and `vladimir putin` all match.
- Small spelling differences are tolerated with Jaro-Winkler token similarity. Middle names and patronymics missing from your input are handled.
- Legal forms and filler words such as `LLC`, `OOO`, `JSC`, `Ltd`, `of` and `the` are ignored for companies.
- Every alias of every entry is checked, including OFAC "a.k.a." names.
- Give a `birthDate` (`YYYY`, `YYYY-MM` or `YYYY-MM-DD`). A matching birth year raises the score. A different birth year lowers it, which removes most namesake false positives.
- Give a `type` (`person` or `entity`) to avoid matching a person against a company or a vessel.

`threshold` (default 0.85) sets how close a name must be to be reported. Lower it to 0.75 to catch more transliteration variants, and expect more false positives to review.

### Input

```json
{
  "names": ["Vladimir Putin", "Rosneft", "Marie Dupont"],
  "entities": [
    { "name": "Yevgeny Prigozhin", "type": "person", "birthDate": "1961-06-01", "reference": "CUST-0042" }
  ],
  "lists": ["EU", "UK", "OFAC", "FR"],
  "threshold": 0.85
}
```

`reference` is copied to the output so you can join the results back to your own records.

If a selected list cannot be downloaded, the run **fails and nothing is charged** by default. Set `failOnListError` to `false` to screen against the lists that loaded instead. The failed lists are then shown on every row.

### Output example

```json
{
  "recordType": "screening",
  "reference": "CUST-0042",
  "inputName": "Yevgeny Prigozhin",
  "status": "match",
  "topScore": 1,
  "matchCount": 4,
  "matchedLists": ["OFAC", "UK", "EU", "FR"],
  "matches": [
    {
      "list": "OFAC",
      "subList": "SDN",
      "id": "21171",
      "matchedName": "PRIGOZHIN, Evgeny",
      "score": 1,
      "dobCheck": "match",
      "type": "person",
      "programs": ["UKRAINE-EO13661", "CYBER2", "ELECTION-EO13848", "RUSSIA-EO14024"],
      "birthDates": ["01 Jun 1961"],
      "sourceUrl": "https://sanctionssearch.ofac.treas.gov/Details.aspx?id=21171"
    }
  ],
  "listsScreened": ["EU", "UK", "OFAC", "FR"],
  "listsFailed": []
}
```

### Pricing

Pay per event:

- **$0.005 per name screened** ($5 per 1,000), whatever the result.
- **$0.01 once per run** for downloading and indexing the official lists.

Screening 1,000 customers costs $5.01. A run that fails before screening is not charged. Use `maxItems` or the run's maximum charge to cap the cost.

### Automate with Make, Zapier or n8n

Use the Apify app in Make, Zapier or n8n with the **Run an Actor and Get Dataset** operation:

1. Pick this Actor and pass the names from your CRM, onboarding form or spreadsheet as `names` or `entities`, with your record id as `reference`.
2. Read the dataset items. Route rows with `status` = `match` or `potential_match` to a compliance review queue, a Slack channel or a CRM field.

For periodic re-screening, schedule a run with the whole customer list, for example every night in the Europe/Paris time zone. You can also call the Actor from your own backend through the Apify API.

### Limits and disclaimer

This Actor is a screening aid, not legal advice. A match is a lead that a person must review. A `no_match` result does not prove that a person or company is not subject to sanctions or other restrictive measures. Ownership-based rules, such as the OFAC 50% rule and EU control rules, sectoral measures and lists other than the four above are not covered. The UN list is not included as a separate list, but UN designations are transposed into the EU and UK lists. Check the official source before taking a decision.

### En français

Contrôle de noms (personnes et sociétés) contre les listes officielles de sanctions : liste consolidée de l'UE, UK Sanctions List, OFAC (SDN et non-SDN) et registre national des gels de la DG Trésor (Licence Ouverte 2.0). Les listes sont téléchargées à chaque exécution. La correspondance tolère les accents, l'ordre des mots, les translittérations du cyrillique et les petites fautes, et la date de naissance permet d'écarter les homonymes. Chaque résultat comporte un lien vers la fiche officielle. Prix : 0,005 $ par nom contrôlé et 0,01 $ par exécution.

# Changelog

This Actor's version history is a separate document: https://apify.com/datacraft-studio/sanctions-screening-eu-uk-us/changelog.md

# Actor input Schema

## `names` (type: `array`):

People or companies to screen, one per line.

## `entities` (type: `array`):

Optional list of objects: {"name": "Ivan Petrov", "type": "person", "birthDate": "1970-05-01", "reference": "CUST-42"}. type is person, entity or any; birthDate is YYYY, YYYY-MM or YYYY-MM-DD and is used to confirm or down-weight matches; reference is copied to the output.

## `lists` (type: `array`):

EU (EU consolidated financial sanctions), UK (UK Sanctions List, FCDO), OFAC (US SDN and consolidated non-SDN) and FR (French national asset-freeze registry).

## `entityType` (type: `string`):

Applied to the names list. Entities can set their own type.

## `threshold` (type: `number`):

Minimum score from 0.7 to 1 to report a match. 0.85 is a balanced default; lower it to catch more spelling variants and review more false positives.

## `maxMatchesPerName` (type: `integer`):

Best matches kept for each name.

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

Stop after this many names. This caps the cost of a run.

## `failOnListError` (type: `boolean`):

On by default: if one selected list cannot be downloaded the run fails and nothing is charged. Turn off to screen against the lists that loaded; failed lists are reported on every row.

## Actor input object example

```json
{
  "names": [
    "Vladimir Putin",
    "Acme Trading Ltd"
  ],
  "lists": [
    "EU",
    "UK",
    "OFAC",
    "FR"
  ],
  "entityType": "any",
  "threshold": 0.85,
  "maxMatchesPerName": 5,
  "maxItems": 10000,
  "failOnListError": true
}
```

# Actor output Schema

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

One row per name screened, then a run summary.

## `summary` (type: `string`):

List versions, counts and the price that applied.

# 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 = {
    "names": [
        "Vladimir Putin",
        "Acme Trading Ltd"
    ],
    "lists": [
        "EU",
        "UK",
        "OFAC",
        "FR"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("datacraft-studio/sanctions-screening-eu-uk-us").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 = {
    "names": [
        "Vladimir Putin",
        "Acme Trading Ltd",
    ],
    "lists": [
        "EU",
        "UK",
        "OFAC",
        "FR",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("datacraft-studio/sanctions-screening-eu-uk-us").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 '{
  "names": [
    "Vladimir Putin",
    "Acme Trading Ltd"
  ],
  "lists": [
    "EU",
    "UK",
    "OFAC",
    "FR"
  ]
}' |
apify call datacraft-studio/sanctions-screening-eu-uk-us --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,datacraft-studio/sanctions-screening-eu-uk-us"
        }
    }
}
```

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/zH5OEsz2bBoSyqUcH/builds/OSLBgVtBuHckGwlcD/openapi.json