# Sanctions Screening Check (`arched_friend/sanctions-screening-check`) Actor

Screen customers, suppliers and counterparties against the US OFAC SDN, UN, UK and EU sanctions lists at once. Fuzzy matching catches spelling variants and aliases. Returns each hit with list, programme, score and source, and flags new designations.

- **URL**: https://apify.com/arched\_friend/sanctions-screening-check.md
- **Developed by:** [Peach O](https://apify.com/arched_friend) (community)
- **Categories:** Business, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$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 Check: OFAC, UN, UK and EU Lists in One Run

Screen your customers, suppliers and counterparties against the US OFAC SDN list, OFAC's non-SDN lists, the UN Security Council list, the UK Sanctions List and the EU financial sanctions list, all in one run. Fuzzy matching catches spelling variants, transliterations and aliases. Every hit comes back with the list, the programme, a match score and a link to the official record.

Built for small compliance teams, fintechs, exporters and marketplaces that need to screen names properly but can't justify an enterprise screening contract.

### How it works

```mermaid
flowchart LR
    A["Your names"] --> F["Fuzzy match on<br/>every name and alias"]
    B["OFAC SDN + non-SDN"] --> F
    C["UN Security Council"] --> F
    D["UK Sanctions List"] --> F
    E["EU Financial Sanctions"] --> F
    F --> G{"Result"}
    G --> H["potential-match<br/>with score and source"]
    G --> I["clear"]
    G --> J["incomplete<br/>(a list failed to load)"]
```

Every list is downloaded fresh from the sanctioning authority on every run, so there's no stale copy and no API key. In testing, all five lists (about 33,000 listed parties and 82,000 names and aliases) loaded in under 30 seconds.

### Built for

- **Fintechs and payment companies** onboarding customers
- **Exporters and freight forwarders** checking buyers, consignees and vessels
- **Marketplaces** screening sellers before payouts
- **Law firms and accountants** checking new clients
- **Procurement teams** checking suppliers before signing

### Input

```json
{
  "names": ["Rosneft", "Acme Widgets Ltd", "Mohammed Hassan Akhund"],
  "entityType": "any",
  "minScore": 85,
  "onlyMatches": false
}
```

| Setting | What it does |
| --- | --- |
| `names` | People, companies or vessels, one per line |
| `lists` | Any of `ofac_sdn`, `ofac_consolidated`, `un`, `uk`, `eu`. All five by default |
| `entityType` | `individual`, `entity`, `vessel`, `aircraft` or `any` |
| `minScore` | How close a name must be to count, 50 to 100. Default 85 |
| `maxMatchesPerName` | Most listed parties returned per name |
| `onlyMatches` | Leave out names that screened clear |
| `onlyChanged` | For a scheduled re-screen: only new or removed matches |

### Output

```json
{
  "name": "Rosneft",
  "status": "potential-match",
  "matchCount": 5,
  "topScore": 100,
  "topMatchName": "OPEN JOINT-STOCK COMPANY ROSNEFT OIL COMPANY",
  "topMatchList": "OFAC SDN (US)",
  "matches": [
    {
      "list": "OFAC SDN (US)",
      "listId": "17022",
      "name": "OPEN JOINT-STOCK COMPANY ROSNEFT OIL COMPANY",
      "matchedName": "ROSNEFT",
      "matchedOn": "alias",
      "score": 100,
      "type": "entity",
      "programs": ["UKRAINE-EO13662", "RUSSIA-EO14024"],
      "countries": ["Russia"],
      "sourceUrl": "https://sanctionssearch.ofac.treas.gov/Details.aspx?id=17022"
    }
  ],
  "listsChecked": ["OFAC SDN (US)", "OFAC Consolidated non-SDN (US)", "UN Security Council", "UK Sanctions List", "EU Financial Sanctions"],
  "listsUnavailable": [],
  "changeType": "first-run",
  "checkedAt": "2026-09-23T18:40:12.000Z"
}
```

Names with a potential match come first, strongest score first.

### How the matching works

Names are compared **word by word, never as substrings**. A substring search finds "PUTIN" inside "COMPUTING"; this one doesn't.

- **Word order and punctuation don't matter.** "Vladimir Putin" matches "PUTIN, Vladimir Vladimirovich".
- **Legal forms are ignored.** LLC, JSC, PJSC, GmbH and similar words don't create or block matches.
- **Transliterations match.** Hussein and Husayn, Mohammed and Muhammad, Osama and Usama, al-Duri and al-Douri.
- **Look-alikes don't.** Putin vs Potanin, Maria vs Aria and Bank vs TBank are all rejected.
- **Aliases count.** Every a.k.a. on every list is searched, and `matchedOn` tells you whether the hit was the primary name or an alias.

A score of 100 is an exact match after normalizing. Around 90 is a likely spelling variant. Around 85 is worth a human look.

### A clear result you can trust

A name is only marked `clear` when **every list you asked for actually loaded**. If a government server is down, names with no match come back as `incomplete`, and `listsUnavailable` says which list is missing. A screening tool that reports "clear" after silently skipping a list is worse than none.

### Re-screen your book on a schedule

Lists change weekly. Save your customer list as the input, turn on `onlyChanged` and schedule a daily run. After the first run, you only hear about:

- `new-match`: someone on your list has just been designated
- `match-removed`: a match disappeared, usually a delisting
- `new-name`: a name you added since the last run

### Run it as an API

```bash
curl -X POST "https://api.apify.com/v2/acts/arched_friend~sanctions-screening-check/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "names": ["Sberbank", "Northwind Trading LLC"],
    "entityType": "entity",
    "onlyMatches": true
  }'
```

### Pricing

You pay $0.005 for each name screened, whether it matches or not.

| Screening 1,000 names a month | Monthly cost |
| --- | --- |
| Checking each name on four government search sites | days of work |
| Enterprise screening platforms | often $300+ per month plus setup |
| This Actor | $5 |

### Common questions

**Is this legal advice or a compliance program?** No. It's a screening aid. A potential match is a lead to review against the official record (linked in `sourceUrl`), not a finding. Your obligations depend on where you operate.

**How many names fit in one run?** About 1,000 in the default 240-second budget. For bigger books, raise `timeBudgetSecs` or split the list across runs.

**Why did "Bank" or a common first name return nothing?** Very generic words count for less, so a single common word doesn't match half the list. Screen full names.

**Does it check dates of birth?** Not yet. Dates of birth and nationalities are returned for each match so a reviewer can rule a hit in or out quickly.

**Do I need an API key?** No. All five lists are public downloads from OFAC, the UN, the UK government and the EU.

### Related products

- **Federal Contract Finder** and **UK Tender Monitor** to vet counterparties in public contracts
- **Company Hiring Monitor** and **Tech Stack Checker** for wider due diligence on a company
- **FDA Recall Monitor** for supplier risk in food, drugs and devices

# Actor input Schema

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

People, companies or vessels, one per line, for example a customer list or a supplier list. Write names the way they appear on documents; order and punctuation do not matter.

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

Which official lists to screen against. All five are downloaded fresh on every run.

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

Only match listed parties of this type. Use Individuals for a customer list of people and Entities for companies to cut unrelated hits.

## `minScore` (type: `integer`):

How close a name must be to count as a potential match, 50 to 100. 85 catches common spelling variants; raise it to cut noise, lower it for a stricter screen.

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

The most listed parties to return for each screened name, strongest first.

## `onlyMatches` (type: `boolean`):

Leave out names that screened clear.

## `onlyChanged` (type: `boolean`):

For a scheduled re-screen: return only names with a new match, a removed match or that were not screened before.

## `requestTimeoutSecs` (type: `integer`):

How long to wait for each official list file. The EU and UK files are 25 to 50 MB.

## `timeBudgetSecs` (type: `integer`):

How long the run may spend screening before it returns what it has. Roughly 1,000 names fit in the default.

## Actor input object example

```json
{
  "names": [
    "Rosneft",
    "Acme Widgets Ltd"
  ],
  "lists": [
    "ofac_sdn",
    "ofac_consolidated",
    "un",
    "uk",
    "eu"
  ],
  "entityType": "any",
  "minScore": 85,
  "maxMatchesPerName": 5,
  "onlyMatches": false,
  "onlyChanged": false,
  "requestTimeoutSecs": 90,
  "timeBudgetSecs": 240
}
```

# Actor output Schema

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

One row per screened name: clear, potential match or incomplete, with every matching listed party, its list, programme, score and source.

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

How many names matched, which lists loaded and how many parties each held.

# 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": [
        "Rosneft",
        "Acme Widgets Ltd"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("arched_friend/sanctions-screening-check").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": [
        "Rosneft",
        "Acme Widgets Ltd",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("arched_friend/sanctions-screening-check").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": [
    "Rosneft",
    "Acme Widgets Ltd"
  ]
}' |
apify call arched_friend/sanctions-screening-check --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,arched_friend/sanctions-screening-check"
        }
    }
}
```

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/UCGlRvGP3eKAwE34B/builds/fiWOvsK9WcRBCzZac/openapi.json