# Sanctions & Watchlist Screener 🛡️ (OFAC, UN, EU, UK) (`tagadanar/sanctions-screener`) Actor

Screen people and companies against the official OFAC SDN, UN, EU, UK OFSI and US Consolidated Screening List, downloaded fresh from government sources on every run. Fuzzy matching with explainable scores. $0.02 per name screened, clean no-hit rows included.

- **URL**: https://apify.com/tagadanar/sanctions-screener.md
- **Developed by:** [Tagada Data](https://apify.com/tagadanar) (community)
- **Categories:** Automation, Developer tools, Agents
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $14.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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Sanctions & Watchlist Screener: OFAC, UN, EU, UK in One Pass

**Screen a list of people or companies against the five major official sanctions and export-control lists in a single run, with explainable match scores.** Paste names, get one row per name: a clear hit or a clean no-hit, with every potential match spelled out (which list, which alias, what score, why it matched). The lists are downloaded fresh from the government sources on every run, so you are never screening against a stale copy.

Built for **compliance officers, fintech and payment teams, exporters and freight forwarders, marketplaces onboarding sellers, and law firms running KYC/AML checks** who need a defensible screening result without paying per-seat SaaS prices.

### Which lists

Every run pulls the current published file straight from the issuing authority. No aggregator in between, no license strings attached:

| List | Issuer | Typical size |
|---|---|---|
| OFAC SDN (Specially Designated Nationals) | US Treasury | ~19,000 parties |
| Consolidated Screening List (Entity List, Denied Persons, ITAR and 10+ more) | US trade.gov | ~26,000 parties |
| UN Security Council Consolidated List | United Nations | ~1,000 parties |
| EU Financial Sanctions (FSF) Consolidated List | European Commission | ~6,000 parties |
| UK OFSI Consolidated List | HM Treasury | ~5,000 parties |

Together that is roughly 57,000 listed parties and 143,000 searchable names and aliases per run.

### Why this actor

- Explainable results, not a black box: every match carries the list, the exact alias that matched, a 70 to 100 score, the match type (exact, token-sort, name-in-name, initials, fuzzy) and a `weak` flag for the match shapes compliance analysts treat with suspicion.
- Clean no-hits are part of the product: a name with zero matches still gets its row, including the exact list versions screened against. That row is your audit trail.
- Real fuzzy matching: "Sberbnak of Rusia" still finds Sberbank at score 89. Transliteration variants, swapped letters, initials ("J. Smith"), names embedded in longer official names, all handled.
- False-positive control: low-quality aliases flagged by the issuing authorities only match exactly, single common names never flood your results, and the sensitivity threshold is yours to set.
- Official sources, refreshed every run: the list dates are in every output row, so you can prove what you screened against and when.
- Batch friendly: up to 10,000 names in one run, and you can pipe a dataset from another actor (company lists, supplier lists) straight in.

### Use cases

- **Customer and vendor onboarding**: screen new accounts, suppliers or sellers before activation.
- **Export compliance**: check consignees and freight parties against the BIS Entity List and Denied Persons in the same pass as OFAC.
- **Periodic re-screening**: schedule a weekly run over your whole customer file and route the hits to your review queue.
- **Deal and transaction checks**: counterparties, UBOs and directors before signing.
- **AI agents**: plug it into Claude, Cursor or any MCP client and ask, *"is this supplier on any sanctions list?"*

### Input

```json
{
    "names": ["Sberbank of Russia", "Wagner Group", "Marie Curie"],
    "threshold": 85
}
````

`names` takes people and companies mixed, up to 10,000 per run. `threshold` sets the minimum reported score: 100 means exact matches only, the default 85 also catches misspellings and containment matches, 70 casts the widest net. `lists` optionally narrows screening to specific lists (`ofac_sdn`, `un`, `eu`, `uk_ofsi`, `us_csl`); the default is all five.

### Output

One row per screened name:

```json
{
    "name": "Sberbank of Russia",
    "screened": true,
    "hit": true,
    "matchCount": 5,
    "topList": "US OFAC Specially Designated Nationals (SDN)",
    "topEntityName": "PUBLIC JOINT STOCK COMPANY SBERBANK OF RUSSIA",
    "topScore": 100,
    "matches": [
        {
            "list": "ofac_sdn",
            "entityName": "PUBLIC JOINT STOCK COMPANY SBERBANK OF RUSSIA",
            "matchedName": "SBERBANK OF RUSSIA",
            "nameType": "aka",
            "score": 100,
            "matchType": "exact",
            "programs": "UKRAINE-EO13662] [RUSSIA-EO14024",
            "weak": false
        }
    ],
    "listsScreened": [
        { "list": "ofac_sdn", "listedParties": 19217, "listDate": "2026-07-15" }
    ],
    "threshold": 85,
    "screenedAt": "2026-07-17T09:00:00.000Z"
}
```

### Pricing

You pay a flat fee per name screened, hit or no hit, plus a small run start fee. Screening 100 vendor names costs about $2. A comparable per-check SaaS subscription typically starts at $49 per month; here there is no seat, no subscription and no minimum.

### FAQ

**Is a hit proof that my counterparty is sanctioned?** No. A hit is a potential match that a human should review; names collide, especially transliterated ones. The score, match type and `weak` flag are there to make that review fast. This actor is a screening aid, not legal advice.

**Why do I get matches for a name that is not exactly on a list?** Fuzzy and containment matching is the point of screening: sanctioned parties rarely appear under one canonical spelling. Raise `threshold` to 100 if you want exact matches only.

**Where does the data come from?** Directly from the issuing authorities (US Treasury, trade.gov, UN, European Commission, HM Treasury) at run time. Nothing is cached between runs and no third-party aggregator is involved.

**What about non-Latin names?** Matching runs on Latin script. Every official list ships Latin transliterations of its entries, and those are all indexed; a query in Arabic or Cyrillic script should be transliterated first.

**Can I screen against just one list?** Yes, set `lists` to the ones your program requires, for example `["ofac_sdn", "us_csl"]` for a US-only export check.

# Actor input Schema

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

One entry per person or company to check. Full names work best (e.g. <code>Sberbank of Russia</code>, not just <code>Sberbank</code>). Bulk lists are fine: paste up to 10,000 names.

## `threshold` (type: `integer`):

Minimum match score to report. 100 returns only exact name matches, the default 85 also catches misspellings, transliteration variants and names contained in longer official names. Lower it toward 70 to cast a wider net (more false positives to review).

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

Which official lists to check. Leave as is for full coverage; narrow it if your compliance program only requires specific jurisdictions.

## Actor input object example

```json
{
  "names": [
    "Sberbank of Russia",
    "Islamic State in Iraq and the Levant",
    "Wagner Group",
    "Marie Curie"
  ],
  "threshold": 85,
  "lists": [
    "ofac_sdn",
    "un",
    "eu",
    "uk_ofsi",
    "us_csl"
  ]
}
```

# Actor output Schema

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

One row per screened name with all matches and list coverage.

# 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": [
        "Sberbank of Russia",
        "Islamic State in Iraq and the Levant",
        "Wagner Group",
        "Marie Curie"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("tagadanar/sanctions-screener").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": [
        "Sberbank of Russia",
        "Islamic State in Iraq and the Levant",
        "Wagner Group",
        "Marie Curie",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("tagadanar/sanctions-screener").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).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": [
    "Sberbank of Russia",
    "Islamic State in Iraq and the Levant",
    "Wagner Group",
    "Marie Curie"
  ]
}' |
apify call tagadanar/sanctions-screener --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=tagadanar/sanctions-screener",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Sanctions & Watchlist Screener 🛡️ (OFAC, UN, EU, UK)",
        "description": "Screen people and companies against the official OFAC SDN, UN, EU, UK OFSI and US Consolidated Screening List, downloaded fresh from government sources on every run. Fuzzy matching with explainable scores. $0.02 per name screened, clean no-hit rows included.",
        "version": "0.1",
        "x-build-id": "hxmPbnUMYbavSvczp"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/tagadanar~sanctions-screener/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-tagadanar-sanctions-screener",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/tagadanar~sanctions-screener/runs": {
            "post": {
                "operationId": "runs-sync-tagadanar-sanctions-screener",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/tagadanar~sanctions-screener/run-sync": {
            "post": {
                "operationId": "run-sync-tagadanar-sanctions-screener",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "names"
                ],
                "properties": {
                    "names": {
                        "title": "Names to screen (people or companies)",
                        "minItems": 1,
                        "type": "array",
                        "description": "One entry per person or company to check. Full names work best (e.g. <code>Sberbank of Russia</code>, not just <code>Sberbank</code>). Bulk lists are fine: paste up to 10,000 names.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "threshold": {
                        "title": "Match sensitivity (70 to 100)",
                        "minimum": 70,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Minimum match score to report. 100 returns only exact name matches, the default 85 also catches misspellings, transliteration variants and names contained in longer official names. Lower it toward 70 to cast a wider net (more false positives to review).",
                        "default": 85
                    },
                    "lists": {
                        "title": "Watchlists to screen against",
                        "type": "array",
                        "description": "Which official lists to check. Leave as is for full coverage; narrow it if your compliance program only requires specific jurisdictions.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "ofac_sdn",
                                "un",
                                "eu",
                                "uk_ofsi",
                                "us_csl"
                            ],
                            "enumTitles": [
                                "US OFAC SDN (Specially Designated Nationals)",
                                "UN Security Council Consolidated List",
                                "EU Financial Sanctions Consolidated List",
                                "UK OFSI Consolidated List",
                                "US Consolidated Screening List (BIS, State, Treasury)"
                            ]
                        },
                        "default": [
                            "ofac_sdn",
                            "un",
                            "eu",
                            "uk_ofsi",
                            "us_csl"
                        ]
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```