# Sanctions Screening Suite: OFAC, EU, UK, UN & PEP Watchlists (`apifmcpfactory/sanctions-screening`) Actor

All-in-one sanctions screening suite for teams and AI agents. Screen, monitor and export against official OFAC, EU, UK OFSI, UN and OpenSanctions PEP watchlists. Get a CLEAR/REVIEW/ESCALATE verdict, auto-cleared false positives, an audit PDF and crypto-wallet screening. Official data, nothing stored

- **URL**: https://apify.com/apifmcpfactory/sanctions-screening.md
- **Developed by:** [Howth Technology Factory](https://apify.com/apifmcpfactory) (community)
- **Categories:** Developer tools, Automation, Agents
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 92.3% runs succeeded, 0 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $10.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 checks names, companies and crypto addresses against five official OFAC, EU, UK and UN sources in one call, and returns a plain-English decision your team can act on instead of a pile of raw rows to interpret yourselves. It does not provide PEP coverage.

### 1. Why use Sanctions Screening

AML and KYC teams doing this by hand open the OFAC SDN and Consolidated lists, the EU Consolidated list, the UK Sanctions List and the UN Consolidated list separately and manually cross-check every name against each one.

Enterprise AML/KYC screening platforms solve the coverage problem, but typically cost $5,000 to $100,000+ a year in licensing before you screen a single name. Most low-cost screening tools sit in between: they fetch one or two lists and hand you a flat list of fuzzy-match rows, leaving you to work out whether three "matches" are actually the same sanctioned person listed three times, whether a hit is a coincidence, and what to do next.

Sanctions Screening is built to close that gap for five direct official sources: cross-list identity consolidation, a documented CLEAR/REVIEW/ESCALATE decision instead of a bare score, and a per-run audit trail, at pay-per-use pricing instead of an annual contract.

### 2. Key features

- **OFAC SDN screening**: the US Treasury's Specially Designated Nationals list, matched with typo and word-order tolerance.
- **OFAC Consolidated screening**: the US Treasury's non-SDN consolidated list, covering additional sanctions programmes.
- **EU Consolidated Financial Sanctions**: the European Commission's official financial sanctions database.
- **UK Sanctions List**: the current FCDO source (the legacy API list key remains `UK OFSI` for compatibility).
- **UN Security Council Consolidated List**: the UN's official sanctions list.
- **AML/KYC risk-programme flags**: matches tagged IRAN, RUSSIA-EO14024, DPRK, CYBER, TERRORISM, PROLIFERATION, GLOBAL-MAGNITSKY and more.
- **Cross-list identity consolidation**: the same person listed by OFAC, the EU, the UK and the UN comes back as one match, not four rows to reconcile by hand.
- **False-positive analysis**: date of birth, country, nationality or identifier mismatches are surfaced explicitly against every match.
- **Denied party crypto address screening**: BTC, ETH and similar wallet addresses checked against OFAC's published digital currency address list.
- **Whitelist memory**: names or list IDs already cleared are suppressed with a documented reason instead of re-flagging every run.
- **PDF audit certificates**: an optional, per-run screening certificate documenting subject, lists, versions, method, threshold and verdict.

### 3. Who it's for

**For compliance and risk teams.** Screen a new corporate customer at onboarding and get a documented CLEAR / REVIEW / ESCALATE verdict with a PDF certificate for the file, instead of four separate list lookups and a spreadsheet note nobody can reconstruct a year later.

**For finance and accounts payable.** Check a payee before releasing a wire, including the crypto wallet address when that is the payment rail, so a blocked party is caught before the funds move rather than after.

**For operations and procurement.** Run a whole supplier list before a contract round, then re-run it on a schedule in monitor mode so a supplier who becomes listed after onboarding surfaces on the next check rather than at audit.

**For developers and AI agents.** Call it as one step inside a KYC intake or payment-release flow: submit the subject, branch on `verdict`, and escalate only ESCALATE and REVIEW to a human — no person copying names between systems.

#### When to use it, and when not to

**Use it** for AML/KYC sanctions screening, denied-party and export-control checks, payment and payee screening, periodic re-screening, and pulling clean structured official-list data into your own systems. Use a separately licensed provider when PEP coverage is required.

**Do not use it** as your compliance programme. It is a screening input, not a determination: it does not decide whether to onboard, block or file a report, it does not replace analyst judgement on REVIEW and ESCALATE verdicts, and it is not legal advice. It also does not do adverse-media screening or full beneficial-ownership tracing — see Limitations for exactly where the boundaries sit.

### 4. Built for humans and AI agents

Run it in the Apify Console like any other tool: pick a mode, enter subjects, click Start. No setup, no API key handling, results in a browser table.

It is also a directly callable MCP tool, so an AI agent (Claude, Cursor, or any MCP-compatible client) can run a sanctions check or PEP watchlist screen as one step inside a larger workflow, such as KYC intake, vendor onboarding, or payment release, without a human copying names between systems.

One example agent call:

```
Tool: apifmcpfactory/sanctions-screening (via https://mcp.apify.com)

Input:
{
    "subjects": [{ "name": "Jane Doe", "country": "Cuba" }],
    "threshold": 85
}

Result (one item):
{
    "subject": "Jane Doe",
    "verdict": "REVIEW",
    "recommendedAction": "Route to a compliance analyst for manual review before proceeding.",
    "matchCount": 1,
    "highestConfidence": 91
}
```

### 5. How to use Sanctions Screening

**In the Apify Console**: pick a mode (screen is the default), fill in your subjects, and click Start. Two working demo subjects are pre-filled so a first run needs no editing.

**Python**:

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("apifmcpfactory/sanctions-screening").call(run_input={
    "subjects": ["AeroCaribbean Airlines", {"name": "Jane Doe", "country": "Cuba"}],
    "threshold": 85,
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["subject"], item["verdict"])
```

**JavaScript**:

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

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });
const run = await client.actor('apifmcpfactory/sanctions-screening').call({
    subjects: ['AeroCaribbean Airlines', { name: 'Jane Doe', country: 'Cuba' }],
    threshold: 85,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

**cURL**:

```bash
curl "https://api.apify.com/v2/acts/apifmcpfactory~sanctions-screening/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"subjects": ["AeroCaribbean Airlines", "Acme Test Company"], "threshold": 85}'
```

### 6. Input parameters

| Field | Type | Description |
|---|---|---|
| `mode` | string | `screen` (default), `monitor`, `export`, `list_status`, or `refresh_cache`. |
| `subjects` | array | Names as plain strings, or objects: `{name, entityType, yearOfBirth, dob, country, nationality, idNumber, passport, regNumber, lei, program}`. |
| `subjectsText` | string | Alternative to `subjects`: one name per line, or a CSV block with a header row. The combined subject limit is 100. |
| `subjectsFileUrl` | string | Alternative to `subjects`: a public URL to a `.csv` or `.xlsx` file of subjects. The combined subject limit is 100. |
| `entityType` | string | `any` (default), `person`, or `org`. A per-subject `entityType` overrides this. |
| `threshold` | integer | Minimum fuzzy-match score, 0 to 100. Default 85. |
| `fuzzy` | boolean | Typo/word-order/transliteration-tolerant matching. Default true. |
| `lists` | array | Restrict screening to specific lists. Default: all five official sources. `UK OFSI` is retained as the API key for the current UK Sanctions List. OpenSanctions requests fail explicitly as unavailable. |
| `whitelist` | array | Names or list entityIds from prior decisions to suppress. |
| `generateCertificate` | boolean | Render a PDF audit certificate for this run. Default false. |
| `priorRunId` | string | Monitor mode only: a prior run's ID to diff against. |
| `webhookUrl` | string | Monitor mode only: POST the change list here if any changes are found. |
| `exportList` | string | Export mode only: which list to dump. |
| `exportFormat` | string | Export mode only: `csv` (default), `json`, or `xlsx`. |

### 7. Output

One dataset row per screened subject in screen mode:

```json
{
    "subject": "Jane Doe",
    "verdict": "REVIEW",
    "recommendedAction": "Route to a compliance analyst for manual review before proceeding.",
    "priorityScore": 78,
    "matchCount": 1,
    "highestConfidence": 91,
    "narrative": "\"Jane Doe\" matched \"Jane A. Doe\" (91/100, strong-fuzzy) on OFAC SDN, EU Consolidated. This match requires analyst review before any decision is made.",
    "matches": [
        {
            "matchedName": "Jane A. Doe",
            "confidence": 91,
            "matchType": "strong-fuzzy",
            "sources": [
                { "list": "OFAC SDN", "entityId": "OFAC SDN-12345", "program": "CUBA", "listVersion": "2026-01-01T00:00:00.000Z", "sourceUrl": "https://sanctionslistservice.ofac.treas.gov/..." },
                { "list": "EU Consolidated", "entityId": "EU Consolidated-987", "program": "Cuba", "listVersion": "2026-01-01T00:00:00.000Z", "sourceUrl": "https://webgate.ec.europa.eu/..." }
            ],
            "riskIndicators": [{ "code": "CYBER", "label": "Cyber-related sanctions programme" }],
            "falsePositiveAnalysis": { "mismatchSignals": [], "likelyFalsePositive": false, "reason": "No contradicting attributes found; name match alone should not be dismissed without analyst review." },
            "autoCleared": false,
            "ownershipRisk": { "flagged": false, "linkedEntities": [], "note": "No ownership/linkage signal found in the source list data for this entry. This is not a full 50%-rule check; beneficial-ownership tracing requires external corporate-registry data this tool does not have." }
        }
    ],
    "whitelisted": false
}
```

#### Field definitions

| Field | Meaning |
|---|---|
| `verdict` | `CLEAR`, `REVIEW`, or `ESCALATE`. |
| `recommendedAction` | Plain-English next step and escalation routing. |
| `priorityScore` | 0 to 100, weighted by confidence, ownership signal, and high-risk programme flags. |
| `matchCount` | Number of consolidated (not raw per-list) matches above threshold, excluding auto-cleared. |
| `highestConfidence` | Highest score among all matches, including auto-cleared ones. |
| `narrative` | Reasoning in plain English, including for a clean result. |
| `matches[].sources` | Every list this consolidated identity appears on. |
| `matches[].riskIndicators` | Programme-category tags parsed from the matched list entries. |
| `matches[].falsePositiveAnalysis` | Concrete attribute mismatches (DOB, country, identifier) versus the subject's own stated data. |
| `matches[].autoCleared` | True when a low-confidence match is contradicted by two or more subject attributes. |
| `matches[].ownershipRisk` | 50 percent rule linkage signal from the source list data, with an explicit non-overclaim note. |

### 8. Use cases

- **Onboarding screening**: check a new customer or counterparty before opening an account.
- **KYC intake**: run an AML watchlist check as part of a standard know-your-customer flow.
- **Payment screening**: check a payee before a wire, including a crypto wallet address if that is the payment rail.
- **Vendor and supplier due diligence**: screen a supplier list in bulk before signing a contract.
- **Denied party screening for export control**: check a buyer or intermediary against sanctions lists before shipping.
- **Periodic re-screening**: use monitor mode on a schedule to catch subjects who become newly listed after onboarding.
- **Marketplace and platform trust and safety**: screen sellers or partners before activating an account.
- **Building your own compliance tooling**: use export mode to pull clean, structured list data into your own systems instead of maintaining five official-source parsers.
- **AI agent workflows**: an agent handling KYC intake or invoice payment can call this tool directly via MCP as one step in a larger flow.

### 9. How it works

```
subjects (names / crypto addresses)
        |
        v
 parse & normalize  ----  accepts array, text, CSV, or XLSX
        |
        v
 fetch + cache lists  ----  OFAC SDN/Consolidated, EU, current UK Sanctions List, UN
        |                   (streamed + parsed incrementally, cached once per day)
        v
 fuzzy match  ----  deterministic, transliteration-aware, per list
        |
        v
 cross-list consolidation  ----  same identity across lists becomes one match
        |
        v
 risk flags + false-positive analysis + ownership signal
        |
        v
 whitelist suppression
        |
        v
 verdict + narrative + audit summary (+ optional PDF certificate)
```

### 10. Performance and cost

| Item | Typical |
|---|---|
| Screening, cached lists | Sub-second per subject once lists are cached. |
| First run or cache refresh | A few minutes, dominated by downloading and parsing the five official files. |
| `entity-screened` event | Charged once per non-empty subject, screen and monitor modes alike. |
| `pdf-certificate` event | Charged once per run when `generateCertificate` is true and the certificate is actually produced, regardless of subject count. |
| `list-exported` event | Charged once per export-mode run, regardless of list size or format. |
| Memory | Runs at 4 GB by default; official lists are streamed and parsed incrementally. |

Wire `mode: "refresh_cache"` to a daily Apify Schedule so ordinary screening calls read from cache instead of re-downloading and re-parsing every list on every call.

### 11. Limitations

- **The OFAC 50 percent rule signal is a signal, not full ownership tracing.** It surfaces only what a source list's own data already states about linked entities. It does not compute beneficial-ownership percentages, and it does not trace ownership through corporate-registry data this tool does not have.
- **No adverse-media data.** This checks structured government and watchlist sources only. It does not search news, litigation, or adverse-media coverage.
- **UK and EU date-of-birth mapping is best effort.** The current UK Sanctions List parser maps available DOB and identifier fields; EU DOB and identifier extraction remains best effort. Treat those attributes as supporting context, not sole decision criteria.
- **Decisions need human review.** A REVIEW or ESCALATE verdict is a prioritised starting point for an analyst, not a final compliance decision, and a CLEAR result means no match was found above your chosen threshold across the lists screened as of the date shown, not a guarantee.
- **No PEP coverage.** OpenSanctions is not downloaded or used because this Actor has no commercial data licence for those feeds. Explicit legacy OpenSanctions requests fail without producing a screening result.
- **Transliteration covers Cyrillic and Greek only.** Arabic, Hebrew and CJK-script names are matched only against whatever Latin rendering the source list already provides.

### 12. Responsible use

This tool is built for legitimate AML, KYC sanctions and denied-party screening workflows. It reads only direct official sources and stores nothing beyond your own run's output. It is not a substitute for a qualified compliance programme, and it is not legal advice. A screening result here should be reviewed by a person before any account, payment, or business decision is made on it, particularly for REVIEW and ESCALATE verdicts.

### 13. FAQ

**What is a denied party or watchlist check?** Screening a name or company against government-published sanctions, embargo, and denied party lists (OFAC, EU, UK, UN and aggregated watchlists) before doing business with them, so you avoid transacting with a sanctioned entity.

**What is the OFAC SDN list?** The US Treasury's Specially Designated Nationals list: individuals and companies US persons are generally prohibited from dealing with.

**What is the difference between OFAC SDN and OFAC Consolidated?** SDN is the primary blocked-persons list. Consolidated covers additional non-SDN sanctions programmes such as sectoral sanctions and other restricted-party lists.

**What is the `UK OFSI` list key?** It is the backwards-compatible API key for the current FCDO UK Sanctions List. The retired OFSI Consolidated List is not used.

**Does this cover PEP screening?** No. This Actor has no commercial OpenSanctions licence and does not download or use those feeds.

**Is this an AML screening tool or a KYC tool?** Both. The same check supports AML watchlist screening at onboarding or before a transaction and ongoing KYC due diligence via monitor mode.

**Why does the same name sometimes get one match instead of several?** Because the same real-world person or company is often listed independently by more than one list. This tool consolidates those into one match with every source listed, rather than returning one row per list.

**What does auto-cleared mean?** A match scored below strong-confidence and contradicted by two or more of the subject's own stated attributes (date of birth, country, or identifier). It is still shown, just flagged so an analyst can deprioritize it.

**Is a CLEAR result guaranteed accurate?** No. It means no match was found above your chosen threshold, across the lists screened, as of the date shown. Lower the threshold to catch more spelling and name-order variants at the cost of more false positives to review.

**Can I re-check the same subjects without re-reading everything?** Yes, use `mode: "monitor"` with `priorRunId` set to a previous run's ID; you get back only what changed.

**Does this screen crypto wallet addresses?** Yes. A subject value shaped like a BTC, ETH or similar address is checked against OFAC's published digital currency address list instead of fuzzy name matching.

**Does this store any of my data?** No. Screening reads only the official public sources listed above and writes only this run's own output.

### 14. Related products

| Product | What it does |
|---|---|
| [IBAN Validator](https://apify.com/apifmcpfactory/iban-validator) | Offline ISO 13616 IBAN checksum and structure validation. |
| [EU VAT Validator](https://apify.com/apifmcpfactory/eu-vat-validator) | Validate EU VAT numbers against the official VIES registry. |
| [Email & Domain Auth Checker](https://apify.com/apifmcpfactory/email-domain-checker) | MX, SPF, DKIM and DMARC checks from DNS alone. |
| [Website Technology Detector](https://apify.com/apifmcpfactory/tech-stack-detector) | Find out what any website is built with. |
| [llms.txt Checker, Generator & Monitor](https://apify.com/apifmcpfactory/llms-txt-suite) | Audit, generate and monitor a site's AI-readiness llms.txt. |
| [PDF Toolkit](https://apify.com/apifmcpfactory/pdf-toolkit) | Merge, split, compress, convert, rotate and watermark PDFs. |

Built by Howth Technology Factory. Precisely engineered tools for teams and AI agents, made in Dublin. Full catalogue: howthtechnologyfactory.pro

# Actor input Schema

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

"screen" (default) checks the subjects below. "monitor" re-screens subjects against freshly-fetched lists and reports only what changed since a prior run. "export" dumps one official list as CSV/JSON/XLSX. "list_status" shows each list's cached record count and last-refresh date. "refresh_cache" force re-fetches all five official lists (wire to a daily Schedule).

## `subjects` (type: `array`):

Plain names as strings, or structured objects for richer matching: {"name": "...", "entityType": "person|org", "yearOfBirth": 1980, "dob": "1980-05-01", "country": "Cuba", "nationality": "Cuban", "idNumber": "...", "passport": "...", "regNumber": "...", "lei": "...", "program": "IRAN"}. A crypto address (BTC/ETH/etc. shape) is screened against OFAC's digital currency address list instead of fuzzy name matching. Across all subject input fields, 1-100 non-empty subjects are accepted and billed once per screened subject.

## `subjectsText` (type: `string`):

One name per line, or a CSV block with a header row (name,entityType,dob,country,nationality,idNumber,passport,regNumber,lei,program). Merged with other subject fields; the combined limit is 100 non-empty subjects and excess input fails without truncation.

## `subjectsFileUrl` (type: `string`):

A public https URL to a .csv or .xlsx file of subjects (same columns as the pasted-text CSV format above). Merged with other subject fields; the combined limit is 100 non-empty subjects and excess input fails without truncation.

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

Narrow matching to persons or organizations only. "any" (default) checks every list entry regardless of type. A per-subject entityType overrides this.

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

Minimum fuzzy-match score (deterministic, transliteration-aware Jaro-Winkler over normalised names and aliases) for a list entry to be returned as a match. Lower catches more spelling/order/script variants but risks false positives; higher is stricter. Default 85.

## `fuzzy` (type: `boolean`):

When true (recommended), names are matched with typo/spelling/word-order tolerance and Cyrillic/Greek-to-Latin transliteration. When false, only exact (or punctuation-only-different) matches count.

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

Restrict screening to specific official lists. Leave empty to screen all five. The legacy API value UK OFSI maps to the current FCDO UK Sanctions List. OpenSanctions values are rejected as unavailable because this Actor has no commercial licence for those feeds.

## `whitelist` (type: `array`):

Names or list entityIds (e.g. "OFAC SDN-36") from prior decisions to suppress. A suppressed match is reported as cleared with reason "whitelisted (prior decision)".

## `generateCertificate` (type: `boolean`):

Renders a one-page-per-subject PDF Sanctions Screening Certificate (lists + versions, method, threshold, verdict, matches) into this run's key-value store. Charged once per run via the pdf-certificate event.

## `priorRunId` (type: `string`):

The Actor run ID of a previous screen/monitor run to diff against, in monitor mode. Omit to establish the first baseline (nothing to diff against yet).

## `webhookUrl` (type: `string`):

In monitor mode, if any changes are found, the change list is POSTed as JSON to this URL. You can also wire Apify's own native webhooks to this Actor's run events for the same purpose.

## `exportList` (type: `string`):

Which list to dump, in export mode.

## `exportFormat` (type: `string`):

Output format for export mode, written to this run's key-value store under the key "EXPORT".

## Actor input object example

```json
{
  "mode": "screen",
  "subjects": [
    "AeroCaribbean Airlines"
  ],
  "entityType": "any",
  "threshold": 85,
  "fuzzy": true,
  "generateCertificate": false,
  "exportList": "OFAC SDN",
  "exportFormat": "csv"
}
```

# Actor output Schema

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

No description

# 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 = {
    "subjects": [
        "AeroCaribbean Airlines"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("apifmcpfactory/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 = { "subjects": ["AeroCaribbean Airlines"] }

# Run the Actor and wait for it to finish
run = client.actor("apifmcpfactory/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 '{
  "subjects": [
    "AeroCaribbean Airlines"
  ]
}' |
apify call apifmcpfactory/sanctions-screening --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,apifmcpfactory/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/ySkheS8vdLtdtfRWd/builds/ZhTexnyWFY1CUqXB6/openapi.json