# AML & Sanctions Screening for AI Agents (OFAC, EU, UN, UK) (`haketa/sanctions-screening`) Actor

Screen any name or company against global sanctions & watchlists (OFAC SDN, EU, UN, UK OFSI) for KYC/AML. Fuzzy name matching with risk scores, programs, aliases, dates of birth & source lists. Real-time compliance grounding for AI agents & LLMs.

- **URL**: https://apify.com/haketa/sanctions-screening.md
- **Developed by:** [Haketa](https://apify.com/haketa) (community)
- **Categories:** AI, Agents, Business
- **Features:** Limited permissions
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

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 & Watchlist Screening Scraper — OFAC, EU, UN & UK for AI Agents, KYC & AML

[![Apify Actor](https://img.shields.io/badge/Apify-Actor-orange?style=flat-square\&logo=apify)](https://apify.com/haketa/sanctions-screening)
[![Maintenance](https://img.shields.io/badge/Maintained%3F-yes-green.svg?style=flat-square)](https://apify.com/haketa/sanctions-screening)
[![Data Export](https://img.shields.io/badge/Export-JSON%20%7C%20CSV%20%7C%20Excel-blue?style=flat-square)](https://apify.com/haketa/sanctions-screening)
[![Compliance](https://img.shields.io/badge/KYC%2FAML-Compliance-brightgreen?style=flat-square)](https://apify.com/haketa/sanctions-screening)
[![Scale](https://img.shields.io/badge/Batch%20Screening-1%2C000%2B%20Names-purple?style=flat-square)](https://apify.com/haketa/sanctions-screening)

**Screen any person or company name against the world's major sanctions and watchlists in a single call.** This **sanctions screening** Actor takes a list of names and returns, for each one, whether it matches a sanctioned party — with a **risk score**, the **sanctions programs**, **aliases**, **dates of birth**, **nationalities**, **addresses** and the **source list** behind every match. Use it to **scrape sanctions data** and screen counterparties across **OFAC SDN, the EU consolidated list, the UN Security Council list and the UK Sanctions List** with no login, no API keys and no coding.

Export every screening result to **JSON, CSV, Excel, or API**.

> Built for **AI agents, KYC/AML onboarding teams, compliance and RegTech tooling, fintechs, payment processors, law firms, OSINT investigators and due-diligence analysts** who need structured, machine-readable sanctions matches on demand.

***

### ⚡ At a glance

| Feature | Details |
| --- | --- |
| **Primary Sources** | US OFAC (SDN + Consolidated), EU Consolidated List, UN Security Council, UK OFSI / FCDO |
| **Entity Database** | 31,000+ sanctioned individuals, companies, banks, vessels & aircraft |
| **Matching Engine** | Recall-first fuzzy matching (Levenshtein distance + token-set containment) |
| **Throughput & Speed** | Screens 1,000+ names in seconds; complete lists indexed in-memory |
| **Keyless & Public** | Official government open data; 100% public-domain sources |
| **Output Formats** | Dataset items in JSON, CSV, Excel, XML, HTML, RSS |
| **Streaming Pipeline** | Chunked dataset push ensuring stable O(1) memory during 10K+ name batches |
| **Integration** | Apify REST API, webhooks, Python SDK, Node.js SDK, LangChain, Make, Zapier |
| **Pricing & Cost** | Low consumption; keyless downloads with no monthly API seat licenses |

***

### 🔎 Why scrape sanctions lists?

Sanctions data is scattered across multiple government websites, each in its own awkward format — one ships raw CSV, another complex XML, another splits names and aliases across separate positional text files, and official download URLs frequently shift. Keeping a live, unified, searchable copy requires heavy maintenance. Furthermore, a large language model **cannot** reliably do this from memory: sanctions lists change **weekly**, and a hallucinated answer in compliance creates unacceptable legal risk.

This **sanctions screening** Actor solves that challenge. It pulls the latest official lists at runtime, unifies them into one clean schema, and fuzzy-matches your submitted names against every alias, spelling variant, and transliteration (e.g. *Wagner* ↔ *Vagner*, Cyrillic ↔ Latin). You get back a single, consistent record per name that an AI agent, spreadsheet, or compliance workflow can consume directly. Because the sources are public, open-license government data, screening is **fast, cost-effective, and always reflects the current designations**.

**Common reasons teams scrape sanctions lists:**

- **KYC / AML onboarding** — screen new customers, suppliers, directors, or beneficial owners before doing business.
- **AI agent compliance grounding** — let an LLM agent verify an entity in real time and receive a structured, sourced verdict.
- **Ongoing portfolio monitoring** — re-screen customer databases on a regular schedule as designations evolve.
- **Transaction & trade compliance** — vet counterparties, intermediaries, and vessels before funds or cargo clear.
- **Due diligence & M\&A investigations** — verify the individuals and corporate holding structures behind deals.
- **RegTech & data pipelines** — feed a unified, de-duplicated sanctions dataset into proprietary screening engines.
- **Journalism & OSINT** — quickly confirm whether an individual or company appears on active sanctions registries.

***

### ✨ What this sanctions screening scraper does

- ✅ **Screens against four major official lists** — US **OFAC** (SDN + Consolidated with alternate names & addresses), the **European Union** consolidated financial sanctions list, the **UN** Security Council Consolidated List, and the **UK Sanctions List** (FCDO/OFSI). That covers **31,000+ sanctioned people, companies, and vessels**.
- ✅ **One clean record per name** — submit 10 names or 10,000; each returns a structured verdict with a confidence score and full match payload.
- ✅ **Recall-first fuzzy matching** — normalizes case, punctuation, and accents, matches against **every alias and transliteration**, and scores each candidate 0–100 with token and edit-distance similarity.
- ✅ **Rich identity fields** — every match carries `name`, `score`, `source`, `type` (Person / Entity / Vessel), `programs`, `countries`, `nationalities`, `birthDates`, `listedOn`, `aliases`, `addresses`, `remarks` (passport / place of birth / reasons), `sourceId`, and `sourceUrl`.
- ✅ **Fine-grained filtering** — filter by **source list**, **entity type** (person / entity / vessel), **country / nationality**, **minimum confidence**, and **max matches per name**.
- ✅ **Always current** — the full lists are re-fetched from official sources on every run, eliminating stale caches.
- ✅ **Fast & scalable** — loads lists once, builds an in-memory index, and screens hundreds of names per second.
- ✅ **Streaming export** — results stream into the dataset in batches of 50, supporting 1,000+ to 10,000+ names with low memory usage.

***

### 🎯 Use cases & workflows

#### 1. Automated Customer Onboarding (Fintech / KYB)

Embed this Actor into your customer signup webhook. When a new merchant or business signs up, immediately check the company name and primary directors. If `isMatch: "true"` and `riskLevel: "high"`, pause approval for compliance review; otherwise, allow instant automated onboarding.

#### 2. Supply Chain & Vendor Risk Management

Screen global suppliers, logistics contractors, and export consignees against OFAC, EU, UN, and UK regimes before issuing purchase orders or signing long-term supplier agreements.

#### 3. Real-Time AI Agent Verification (LangChain / LlamaIndex)

Equip customer support bots, trade finance copilots, or corporate research agents with an API-driven tool to verify entity names before generating answers or recommending actions.

#### 4. Cross-Border M\&A and Real Estate Due Diligence

Run batch checks across all corporate board members, major shareholders, holding companies, and asset sellers involved in complex acquisitions or high-value property transfers.

#### 5. Scheduled Portfolio Audit

Set up a weekly Apify schedule to re-screen your active client list against updated watchlists. Flag any new designations automatically via email alerts or Slack webhooks.

***

### 📥 Input parameters

Submit the names you want to screen along with your preferred filters. Every field is optional — running the Actor empty executes a built-in demo screening well-known sanctioned entities.

| Field | Type | Default | Description |
| --- | --- | --- | --- |
| `queries` | array | — | People or company names to screen, one per line (e.g. `"Vladimir Putin"`, `"Acme Trading LLC"`). Leave empty for demo sample. |
| `maxItems` | integer | `0` | Maximum names to screen (0 = unlimited, screens all provided names). Supports 1,000+ names. |
| `sources` | array | `["OFAC","EU","UN","UK"]` | Which official watchlists to check: `OFAC`, `EU`, `UN`, `UK`. |
| `entityType` | string | `all` | Restrict matches to `all`, `person`, `entity`, or `vessel`. |
| `country` | string | `""` | Filter matches by linked country / nationality (dropdown of common jurisdictions). |
| `countryCustom` | string | — | Advanced: free-text country or ISO code not present in the dropdown. |
| `minScore` | integer | `85` | Minimum match confidence score (40–100). Lower scores catch looser matches; 85 is recommended. |
| `maxMatchesPerQuery` | integer | `10` | Maximum best matches to return for each submitted name. |
| `proxyConfiguration` | object | off | Optional Apify Proxy settings (public endpoints operate keyless and proxy-free by default). |

#### Example input — targeted KYC check

```json
{
  "queries": [
    "Vladimir Putin",
    "Wagner Group",
    "Nicolas Maduro",
    "Acme Trading LLC",
    "Jane Doe"
  ],
  "sources": ["OFAC", "EU", "UN", "UK"],
  "entityType": "all",
  "minScore": 85,
  "maxMatchesPerQuery": 5,
  "maxItems": 0
}
```

#### Example input — 1,000+ bulk corporate screening

```json
{
  "queries": [
    "Gazprom Neft",
    "Rosneft Oil Company",
    "Al-Quds Force",
    "Bank Mellat",
    "Sberbank of Russia"
  ],
  "sources": ["OFAC", "EU", "UK"],
  "entityType": "entity",
  "minScore": 80,
  "maxMatchesPerQuery": 3,
  "maxItems": 1000
}
```

***

### 📤 Output structure

For every submitted name, the Actor outputs **one record** in the dataset. Flat `topMatch*` fields allow immediate triage in spreadsheet tools, while the `matches` array holds the complete matching entity payload.

#### Positive match record

```json
{
  "query": "Vladimir Putin",
  "isMatch": "true",
  "riskLevel": "high",
  "matchCount": "2",
  "topScore": "100",
  "topMatchName": "PUTIN, Vladimir Vladimirovich",
  "topMatchSource": "OFAC",
  "topMatchType": "Person",
  "topMatchPrograms": "RUSSIA-EO14024",
  "topMatchListedOn": "",
  "matchesSummary": "PUTIN, Vladimir Vladimirovich (100%, OFAC: RUSSIA-EO14024) | Vladimir Vladimirovich PUTIN (100%, UK: The Russia (Sanctions) (EU Exit) Regulations 2019)",
  "matches": [
    {
      "name": "PUTIN, Vladimir Vladimirovich",
      "score": 100,
      "source": "OFAC",
      "type": "Person",
      "programs": ["RUSSIA-EO14024"],
      "countries": [],
      "nationalities": [],
      "birthDates": [],
      "listedOn": "",
      "aliases": ["PUTIN, Vladimir"],
      "addresses": [
        "Kremlin, Moscow, Russia",
        "Novo-Ogaryevo, Moscow Region, Russia",
        "Bocharov Ruchey, Sochi, Russia"
      ],
      "remarks": "DOB 07 Oct 1952; POB Leningrad, Russia; nationality Russia; citizen Russia; Gender Male; President of the Russian Federation.",
      "sourceId": "35096",
      "sourceUrl": "https://sanctionssearch.ofac.treas.gov/"
    }
  ],
  "screenedAt": "2026-11-10T15:45:00.000Z"
}
```

#### Clean / non-match record

```json
{
  "query": "Acme Global Software Inc",
  "isMatch": "false",
  "riskLevel": "none",
  "matchCount": "0",
  "topScore": "0",
  "topMatchName": "",
  "topMatchSource": "",
  "topMatchType": "",
  "topMatchPrograms": "",
  "topMatchListedOn": "",
  "matchesSummary": "No sanctions match found.",
  "matches": [],
  "screenedAt": "2026-11-10T15:45:00.000Z"
}
```

***

### 📊 Extracted fields & data coverage

#### Top-level record fields

| Field | Coverage | Type | Description |
| --- | --- | --- | --- |
| 🏷️ `query` | 🟢 High (100%) | String | The exact name or query submitted for screening |
| 🛡️ `isMatch` | 🟢 High (100%) | String | `"true"` or `"false"` indicating if a match meets `minScore` |
| ⚠️ `riskLevel` | 🟢 High (100%) | String | Risk categorization: `none`, `low`, `medium`, or `high` |
| 🔢 `matchCount` | 🟢 High (100%) | String | Total number of matches meeting threshold criteria |
| 📈 `topScore` | 🟢 High (100%) | String | Highest confidence score obtained (0–100) |
| 👤 `topMatchName` | 🟡 Conditional | String | Full legal name of the highest-scoring entity match |
| 🏛️ `topMatchSource` | 🟡 Conditional | String | Watchlist source of the top hit (`OFAC`, `EU`, `UN`, `UK`) |
| 🏢 `topMatchType` | 🟡 Conditional | String | Categorization of top match (`Person`, `Entity`, `Vessel`) |
| 📜 `topMatchPrograms` | 🟡 Conditional | String | Sanctions regimes and executive orders associated with hit |
| 📅 `topMatchListedOn` | ⚪ Optional | String | Official date of designation when provided by the regime |
| 📝 `matchesSummary` | 🟢 High (100%) | String | Concatenated overview string summarizing top candidates |
| 📦 `matches` | 🟢 High (100%) | Array | Complete array of detailed match objects |
| ⏰ `screenedAt` | 🟢 High (100%) | String | ISO 8601 UTC timestamp of execution |

#### Nested `matches[]` candidate fields

| Field | Coverage | Type | Description |
| --- | --- | --- | --- |
| 🏷️ `name` | 🟢 High (100%) | String | Primary recorded name on official designation registry |
| 🎯 `score` | 🟢 High (100%) | Number | Fuzzy confidence score between 0 and 100 |
| 🏛️ `source` | 🟢 High (100%) | String | Authoritative registry code (`OFAC`, `EU`, `UN`, `UK`) |
| 🏢 `type` | 🟢 High (100%) | String | Entity designation type (`Person`, `Entity`, `Vessel`) |
| 📜 `programs` | 🟢 High (100%) | Array | List of official program codes or statutory instruments |
| 🌍 `countries` | 🟡 Conditional | Array | Countries associated with the designated entity |
| 🌐 `nationalities` | 🟡 Conditional | Array | Recorded nationalities (primarily individuals) |
| 🎂 `birthDates` | 🟡 Conditional | Array | Dates or calendar years of birth |
| 📅 `listedOn` | ⚪ Optional | String | Specific registration or designation date |
| 🪪 `aliases` | 🟢 High (~85%) | Array | Known alternative spellings, AKAs, and transliterations |
| 📍 `addresses` | 🟡 Conditional | Array | Registered business or residential addresses |
| 📋 `remarks` | 🟢 High (~97%) | String | Official identity remarks (passports, POB, titles, UBO notes) |
| 🆔 `sourceId` | 🟢 High (100%) | String | Official identification key from source database |
| 🔗 `sourceUrl` | 🟢 High (100%) | String | URL to the authoritative registry documentation |

***

### 🔁 Scale & 1,000+ bulk screening

This Actor does not rely on fragile page-by-page web scraping. It fetches official, authoritative bulk files directly into an optimized in-memory token index. This design enables enterprise-grade high-volume compliance operations:

- **1,000+ to 10,000+ names per run** — submit extensive vendor lists or customer portfolios without timeout risks.
- **Streaming dataset push** — results stream to the Apify dataset in batches of 50, preventing memory bloat and preserving state.
- **De-duplicated candidate rankings** — each submitted query evaluates against all 31,000+ targets and returns de-duplicated, score-ordered results.
- **Zero rate limiting on queries** — since screening executes locally in-memory after download, your query volume is limited only by runtime compute.

***

### 💻 Developer integration & code samples

#### Python SDK

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

run_input = {
    "queries": [
        "Vladimir Putin",
        "Wagner Group",
        "Acme Trading LLC"
    ],
    "sources": ["OFAC", "EU", "UN", "UK"],
    "minScore": 85,
    "maxMatchesPerQuery": 5
}

run = client.actor("haketa/sanctions-screening").call(run_input=run_input)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(f"Query: {item['query']} | Match: {item['isMatch']} | Risk: {item['riskLevel']}")
```

#### Node.js SDK

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

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });

const run = await client.actor('haketa/sanctions-screening').call({
    queries: ['Vladimir Putin', 'Wagner Group', 'Acme Trading LLC'],
    sources: ['OFAC', 'EU', 'UN', 'UK'],
    minScore: 85,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.table(items.map(i => ({ query: i.query, match: i.isMatch, risk: i.riskLevel, top: i.topMatchName })));
```

#### cURL API

```bash
curl -X POST "https://api.apify.com/v2/acts/haketa~sanctions-screening/runs?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "queries": ["Vladimir Putin", "Wagner Group", "Acme Trading LLC"],
    "minScore": 85,
    "maxMatchesPerQuery": 5
  }'
```

***

### 💡 Best practices for AML screening

1. **Threshold calibration** — use `85` as standard. For common names (e.g., "Maria Garcia", "John Smith"), raise `minScore` to `90–95` to reduce false positives.
2. **Jurisdiction scoping** — when customer residency is known, filter with `country` to suppress unrelated international matches.
3. **Always examine remarks** — official passport numbers, dates of birth, and places of birth frequently appear in `remarks`.
4. **Regular batch runs** — schedule daily or weekly runs using Apify Schedules to screen your ongoing customer master file against new sanctions designations.

***

### ❓ Frequently Asked Questions

**Which sanctions registries are included?**\
The Actor screens US OFAC (SDN and Consolidated), the European Union consolidated sanctions list, the United Nations Security Council Consolidated List, and the UK Sanctions List (OFSI/FCDO). Over 31,000 distinct entities are indexed.

**Are private API keys required?**\
No. The Actor downloads official public-domain governmental datasets directly. No third-party API subscriptions or login credentials are required.

**How does fuzzy matching handle transliterations?**\
Names are normalized (accents stripped, case-folded, tokenized) and scored using a hybrid Levenshtein distance and token-containment metric. Transliterations between Latin, Cyrillic, and Arabic naming conventions are matched accurately.

**Can I run 5,000 names at once?**\
Yes. The in-memory index evaluates hundreds of names per second, and dataset records are streamed in batches of 50 to maintain optimal performance.

**What formats can I download?**\
Datasets can be downloaded instantly in JSON, CSV, Excel, XML, HTML, or JSON Lines formats via the Apify Console or API.

**How fresh is the sanctions data?**\
It is pulled directly from the official government endpoints on every run, so you always screen against the current, live lists without stale caching.

**How do I distinguish false positives on common names?**\
Examine the `birthDates`, `nationalities`, `addresses`, and `remarks` fields returned within each match object to verify identity before taking compliance actions.

***

### 🔗 Related compliance & intelligence scrapers

- [GLEIF LEI Lookup](https://apify.com/haketa/gleif-lei) — verify legal entities, corporate identifiers, and registration statuses for KYB onboarding.
- [SEC EDGAR Scraper](https://apify.com/haketa/sec-edgar-scraper) — extract SEC filings, 10-K, 10-Q, and executive insider transactions.
- [Vessel Tracker](https://apify.com/haketa/vessel-tracker) — track maritime shipping vessels, IMO numbers, and AIS movements.
- [Bulk Metadata Extractor](https://apify.com/haketa/bulk-metadata-extractor) — extract Open Graph, Twitter Cards, and schema.org microdata in bulk.

***

### 📋 Changelog

#### v1.2 (2026-11)

- **Unlocked 1,000+ batch screening**: added `maxItems` support and transitioned to streaming dataset writes in chunks of 50 records.
- **Memory optimization**: reduced memory footprint during high-volume queries with streaming index matching.
- **Enhanced field normalization**: improved cross-source parsing of passport numbers, aliases, and corporate designation notes in `remarks`.
- **Expanded documentation**: added visual badges, `⚡ At a glance` quick reference, and comprehensive field coverage indicators.

#### v1.1 (2026-07)

- Multi-source integration: unified OFAC, EU, UN, and UK OFSI into single screening interface.
- Added country, entity type, and confidence threshold filtering options.

#### v1.0 (2026-06)

- Initial release with keyless public-domain sanctions verification.

# Changelog

This Actor's version history is a separate document: https://apify.com/haketa/sanctions-screening/changelog.md

# Actor input Schema

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

Add the people or company names you want to check against global sanctions lists, one per line (e.g. "Vladimir Putin", "Acme Trading LLC"). Leave this empty to run a ready-made demo that screens a diverse sample of well-known sanctioned names.

## `sources` (type: `array`):

Pick which official watchlists to screen against. Select all for the widest coverage, or narrow it to the regions you care about.

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

Choose whether to return matches for everyone, only people, only companies/organisations, or only vessels.

## `country` (type: `string`):

Optionally keep only matches linked to a specific country or nationality. Choose a country from the list, or pick "Any country" to keep every match.

## `countryCustom` (type: `string`):

Power users only: type any country or nationality (name or ISO code) not in the list above. Leave empty if you already picked one above.

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

Only return matches at or above this confidence (0-100). Lower values surface more possible matches but add noise. 85 is a solid default for screening.

## `maxMatchesPerQuery` (type: `integer`):

How many of the best matches to return for each screened name.

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

Maximum number of names to screen from your input list. Set to 0 or leave empty for unlimited (screens all provided names). Supports 1,000+ batch screening.

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

Apify Proxy settings. The official lists are public, so a proxy is off by default and rarely needed.

## Actor input object example

```json
{
  "queries": [
    "Vladimir Putin",
    "Wagner Group",
    "Nicolas Maduro"
  ],
  "sources": [
    "OFAC",
    "EU",
    "UN",
    "UK"
  ],
  "entityType": "all",
  "country": "",
  "minScore": 85,
  "maxMatchesPerQuery": 10,
  "maxItems": 50,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `datasetItems` (type: `string`):

All screening records for this run, one per screened name.

## `overviewTable` (type: `string`):

A clean, human-readable table of every screened name and its top sanctions match.

# 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": [
        "Vladimir Putin",
        "Wagner Group",
        "Nicolas Maduro"
    ],
    "sources": [
        "OFAC",
        "EU",
        "UN",
        "UK"
    ],
    "minScore": 85,
    "maxMatchesPerQuery": 10,
    "maxItems": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("haketa/sanctions-screening").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": [
        "Vladimir Putin",
        "Wagner Group",
        "Nicolas Maduro",
    ],
    "sources": [
        "OFAC",
        "EU",
        "UN",
        "UK",
    ],
    "minScore": 85,
    "maxMatchesPerQuery": 10,
    "maxItems": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("haketa/sanctions-screening").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": [
    "Vladimir Putin",
    "Wagner Group",
    "Nicolas Maduro"
  ],
  "sources": [
    "OFAC",
    "EU",
    "UN",
    "UK"
  ],
  "minScore": 85,
  "maxMatchesPerQuery": 10,
  "maxItems": 50
}' |
apify call haketa/sanctions-screening --silent --output-dataset

```

## MCP server setup

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

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/W0DRTLEWvVeOahrYE/builds/zadKxyb1CYKYLlzkQ/openapi.json