# OpenSanctions Sanctions & PEP Entities Scraper (`parseforge/opensanctions-entities-scraper`) Actor

Scrape OpenSanctions: 280k+ sanctioned people, companies, vessels and PEPs across 250+ global watchlists. Filter by topic, country, entity type or dataset. Returns names, aliases, identifiers, addresses, sectors, programmes — for AML, KYC and due diligence.

- **URL**: https://apify.com/parseforge/opensanctions-entities-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Business, Automation, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $22.50 / 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.
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.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.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/platform/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

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/main/banners/banner-default.jpg?raw=true)

## 🛡️ OpenSanctions Sanctions & PEP Entities Scraper

> 🚀 **Export the global sanctions and PEP universe in seconds.** Pull **280,000+ sanctioned individuals, companies, vessels, and politically exposed persons** consolidated from 250+ official watchlists. No sign-up, no manual list stitching, no per-source parsers.

> 🕒 **Last updated:** 2026-05-15 · **📊 30 fields** per record · **🛡️ 280,000+ entities** · **🌍 250+ source watchlists** · **⚖️ AML / KYC / Due Diligence ready**

The **OpenSanctions Entities Scraper** exports the consolidated OpenSanctions catalogue and returns up to **30 structured fields per record**, including canonical names, aliases, gender, nationality, identifiers (passport, INN, OGRN, LEI, IMO), addresses, sectors, sanction programmes, topic flags, and the underlying source lists. The OpenSanctions catalogue is one of the most widely cited consolidated watchlist sources in the AML, KYC, and investigative-journalism communities.

The catalogue covers **every major sanctions regime, PEP register, and crime / wanted list on Earth**, from the U.S. OFAC SDN list and EU Financial Sanctions Files to the UK HMT list, UN Security Council sanctions, Russian Wanted lists, and dozens of national debarment registries. This Actor makes that data downloadable as CSV, Excel, JSON, or XML in under five minutes. Filters run server-side, so you skip the merge engineering entirely.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Compliance, AML, and KYC teams; banks and fintechs; legal and due-diligence firms; investigative journalists; OSINT and risk analysts; crypto exchanges; corporate procurement | Sanctions screening, PEP detection, ultimate-beneficial-owner research, vessel and aircraft watchlist checks, supplier debarment screening, adverse-media triage, periodic refresh of internal watchlists |

---

### 📋 What the OpenSanctions Entities Scraper does

Six filtering workflows in a single run:

- 🛡️ **Consolidated sanctions.** The full union of OFAC, EU FSF, UK HMT, UN, Australia DFAT, Canada SEMA, and 60+ other sanctions regimes.
- 🏛️ **PEP register.** Politically exposed persons across heads of state, ministers, judges, diplomats, and family members (RCAs).
- 🚓 **Crime and wanted lists.** Interpol, FBI, national police bulletins, financial crime, terrorism, trafficking, cybercrime, and fraud topics.
- 🚫 **Debarment registers.** World Bank, UN, EU, U.S. SAM excluded suppliers and procurement bans.
- 🌍 **Country filter.** Restrict to entities tied to a single country code (e.g. `ru`, `ir`, `kp`, `cn`, `us`).
- 🏷️ **Type, topic, name, and source slug filters.** Combine freely (e.g. all sanctioned vessels, or all PEPs in Iran, or every Person flagged for fraud).

Each record includes the canonical display name, every recorded alias and transliteration, gender and nationality, structured identifiers (passport, INN, OGRN, LEI, IMO), addresses, sectors, sanction programmes, topic flags, the source datasets the entity came from, original source URLs, first-seen and last-changed timestamps, and a deep link to the public OpenSanctions profile.

> 💡 **Why it matters:** sanctions, PEP, and watchlist screening is the foundation of AML compliance, payment risk scoring, and KYC onboarding. Building your own consolidated list means writing parsers for 250+ sources, deduping across regimes, normalising aliases, and refreshing daily. This Actor skips all of that and gives you a clean, refreshed snapshot on every run.

---

### 🎬 Full Demo

_🚧 Coming soon: a 3-minute walkthrough showing how to go from sign-up to a downloaded sanctions dataset._

---

### ⚙️ Input

<table>
<thead>
<tr><th>Input</th><th>Type</th><th>Default</th><th>Behavior</th></tr>
</thead>
<tbody>
<tr><td><code>dataset</code></td><td>string</td><td><code>"sanctions"</code></td><td>Which collection to pull from: <code>sanctions</code>, <code>peps</code>, <code>crime</code>, <code>debarment</code>, or <code>default</code> (full union).</td></tr>
<tr><td><code>schema</code></td><td>string</td><td><code>""</code></td><td>Restrict to one entity type: Person, Organization, Company, LegalEntity, Vessel, Airplane, Position, or CryptoWallet.</td></tr>
<tr><td><code>country</code></td><td>string</td><td><code>""</code></td><td>ISO 3166-1 alpha-2 lowercase (e.g. <code>ru</code>, <code>ir</code>, <code>kp</code>). Empty = all countries.</td></tr>
<tr><td><code>topic</code></td><td>string</td><td><code>""</code></td><td>Risk topic flag (sanction, role.pep, role.rca, crime.fin, crime.terror, debarment, wanted, asset.frozen, and more).</td></tr>
<tr><td><code>nameQuery</code></td><td>string</td><td><code>""</code></td><td>Case-insensitive substring on the canonical name or any alias.</td></tr>
<tr><td><code>datasetSource</code></td><td>string</td><td><code>""</code></td><td>Restrict to a specific source list slug (e.g. <code>us_ofac_sdn</code>, <code>eu_fsf</code>, <code>gb_hmt_sanctions</code>, <code>un_sc_sanctions</code>).</td></tr>
<tr><td><code>maxItems</code></td><td>integer</td><td><code>10</code></td><td>Records to return. Free plan caps at 10, paid plan at 1,000,000.</td></tr>
</tbody>
</table>

**Example: 100 sanctioned organisations linked to Russia.**

```json
{
    "maxItems": 100,
    "dataset": "sanctions",
    "schema": "Organization",
    "country": "ru"
}
````

**Example: every Iranian PEP captured by the consolidated PEP register.**

```json
{
    "maxItems": 500,
    "dataset": "peps",
    "country": "ir",
    "topic": "role.pep"
}
```

> ⚠️ **Good to Know:** the OpenSanctions catalogue aggregates official watchlists, and each entry inherits the position and accuracy of its source. Always treat sanctions / PEP hits as a screening signal and verify against the original publishing authority before taking commercial or legal action. The `sourceUrls` field gives you a direct link back to the issuing list for every record.

***

### 📊 Output

Each entity record carries up to **30 fields**. Download the dataset as CSV, Excel, JSON, or XML.

#### 🧾 Schema

| Field | Type | Example |
|---|---|---|
| 🆔 `id` | string | `"NK-223CQDBzp8MRkdJMDiqXn3"` |
| 🏷️ `caption` | string | `"Myanmar Yatai International Holding Group Co., LTD."` |
| 🔗 `profileUrl` | string | `"https://www.opensanctions.org/entities/NK-..."` |
| 📂 `schema` | string | `"Organization"` |
| 🎯 `target` | boolean | `true` |
| 🏷️ `names` | array | `["Myanmar Yatai International Holding Group Co., LTD."]` |
| 🏷️ `aliases` | array | `["Yatai New City", "Shwe Kokko Special Economic Zone"]` |
| 📅 `birthDates` | array | null | `["1958-12-04"]` |
| 👤 `gender` | string | null | `"male"` |
| 🌍 `nationality` | string | null | `"ru"` |
| 🌍 `countries` | array | `["mm"]` |
| 🌍 `jurisdictions` | array | `["mm"]` |
| 🏠 `addresses` | array | `["Shwe Kokko Village, Myawaddy Township, Karen State"]` |
| 🏭 `sectors` | array | `["Construction of buildings"]` |
| 💼 `positions` | array | `["Member of the State Duma"]` |
| 🆔 `idNumbers` | array | `["AB123456"]` |
| 🛂 `passportNumbers` | array | `["741234567"]` |
| 🆔 `registrationNumbers` | array | `["103919088"]` |
| 🆔 `innCodes` | array | `["7706107510"]` |
| 🆔 `ogrnCodes` | array | `["1027700132195"]` |
| 🆔 `leiCodes` | array | `["549300NLPGUTKZ16PA67"]` |
| 🚢 `imoNumbers` | array | `["9123456"]` |
| 📜 `sanctionProgrammes` | array | `["US-GLOMAG"]` |
| 🏷️ `topics` | array | `["sanction"]` |
| 📦 `datasets` | array | `["us_ofac_sdn", "us_trade_csl"]` |
| 📝 `notes` | array | `["Designated under Executive Order 13818..."]` |
| 🔗 `sourceUrls` | array | `["https://sanctionssearch.ofac.treas.gov/Details.aspx?id=54742"]` |
| 📅 `firstSeen` | ISO 8601 | `"2025-09-08T14:10:01"` |
| 📅 `lastSeen` | ISO 8601 | `"2026-05-15T12:53:02"` |
| 🕒 `lastChange` | ISO 8601 | `"2026-01-26T16:10:01"` |
| 🕒 `scrapedAt` | ISO 8601 | `"2026-05-15T18:20:11.419Z"` |

#### 📦 Sample record

<details>
<summary><strong>🛡️ Sanctioned organisation: Myanmar Yatai International Holding Group</strong></summary>

```json
{
    "id": "NK-223CQDBzp8MRkdJMDiqXn3",
    "caption": "Myanmar Yatai International Holding Group Co., LTD.",
    "profileUrl": "https://www.opensanctions.org/entities/NK-223CQDBzp8MRkdJMDiqXn3/",
    "schema": "Organization",
    "target": true,
    "names": ["Myanmar Yatai International Holding Group Co., LTD."],
    "aliases": ["Yatai New City", "Shwe Kokko Special Economic Zone", "Yatai Smart Industrial New City"],
    "countries": ["mm"],
    "addresses": ["Shwe Kokko Village, Myawaddy Township, Karen State", "Hpa-An City"],
    "sectors": ["Construction of buildings"],
    "registrationNumbers": ["103919088"],
    "sanctionProgrammes": ["US-GLOMAG"],
    "topics": ["sanction"],
    "datasets": ["us_ofac_sdn", "us_trade_csl"],
    "sourceUrls": ["https://sanctionssearch.ofac.treas.gov/Details.aspx?id=54742"],
    "firstSeen": "2025-09-08T14:10:01",
    "lastSeen": "2026-05-15T12:53:02",
    "lastChange": "2026-01-26T16:10:01",
    "scrapedAt": "2026-05-15T18:20:11.419Z"
}
```

</details>

***

### ✨ Why choose this Actor

| | Capability |
|---|---|
| 🌍 | **Global coverage.** 280,000+ entities consolidated from 250+ official watchlists across every major jurisdiction. |
| 🛡️ | **Five collections.** Consolidated sanctions, PEPs, crime / wanted, debarment, or the full union, picked at run time. |
| 🔖 | **Strong identifiers.** Passport, INN, OGRN, LEI, IMO, registration numbers cover persons, companies, and vessels. |
| ⚡ | **Fast.** 10 entities in seconds, 100,000 records in a few minutes. |
| 🌐 | **Cited industry source.** Used by AML vendors, fintech compliance teams, and investigative journalists worldwide. |
| 🔁 | **Always fresh.** Every run pulls the latest consolidated catalogue, so your dataset reflects current designations. |
| 🚫 | **No authentication.** Public open-data licence. No login required. |

> 📊 Accurate sanctions and PEP master data sits at the heart of every onboarding flow, payment screen, and supplier-risk review in modern finance.

***

### 📈 How it compares to alternatives

| Approach | Cost | Coverage | Refresh | Filters | Setup |
|---|---|---|---|---|---|
| **⭐ OpenSanctions Entities Scraper** *(this Actor)* | $5 free credit, then pay-per-use | **280,000+ entities, 250+ lists** | **Live per run** | dataset, type, country, topic, name, source slug | ⚡ 2 min |
| Commercial AML data feeds | $20k - $250k/year | Comparable + adverse media | Daily | Many | 🐢 Weeks (procurement) |
| Direct OFAC / EU / UN scraping | Free | Single regime each | Manual | Source-specific | 🕒 Days per source |
| Static CSV dumps | Free | Stale snapshot | Rarely | None | ⏳ Hours |

Pick this Actor when you want consolidated multi-regime coverage, server-side filtering, and zero pipeline maintenance.

***

### 🚀 How to use

1. 📝 **Sign up.** [Create a free account w/ $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp) (takes 2 minutes).
2. 🌐 **Open the Actor.** Go to the OpenSanctions Sanctions & PEP Entities Scraper page on the Apify Store.
3. 🎯 **Set input.** Pick a collection (sanctions / peps / crime / debarment), optionally add a country, topic, or name filter, and set `maxItems`.
4. 🚀 **Run it.** Click **Start** and let the Actor stream the consolidated catalogue.
5. 📥 **Download.** Grab your results in the **Dataset** tab as CSV, Excel, JSON, or XML.

> ⏱️ Total time from signup to a downloaded sanctions dataset: **3-5 minutes.** No coding required.

***

### 💼 Business use cases

<table>
<tr>
<td width="50%" valign="top">

#### 🏦 AML & KYC Onboarding

- Daily sanctions and PEP refresh for screening engines
- Vessel and aircraft watchlist checks for trade finance
- Enrich onboarding decisions with topic and programme flags
- Track first-seen / last-changed for adverse-event alerting

</td>
<td width="50%" valign="top">

#### 🛒 Procurement & Vendor Risk

- Debarment screening across World Bank, UN, EU, U.S. SAM
- Supplier UBO checks against consolidated PEP register
- Sector and registration-number cross-joins for supplier graphs
- Continuous monitoring with scheduled refreshes

</td>
</tr>
<tr>
<td width="50%" valign="top">

#### 📰 Investigative Journalism & OSINT

- Cross-reference shell companies with sanctioned UBOs
- Link vessels, aircraft, and crypto wallets to designated owners
- Map sanctions programmes by country and time window
- Build evidence trails from `sourceUrls` back to issuing authority

</td>
<td width="50%" valign="top">

#### 💸 Crypto & Payments

- Crypto wallet screening against OFAC SDN designations
- Payment-rail PEP detection for high-risk corridors
- Adverse-news triage seeded with consolidated alias lists
- Real-time dataset refresh for transaction-monitoring vendors

</td>
</tr>
</table>

***

### 🔌 Automating OpenSanctions Scraper

Control the scraper programmatically for scheduled runs and pipeline integrations:

- 🟢 **Node.js.** Install the `apify-client` NPM package.
- 🐍 **Python.** Use the `apify-client` PyPI package.
- 📚 See the [Apify API documentation](https://docs.apify.com/api/v2) for full details.

The [Apify Schedules feature](https://docs.apify.com/platform/schedules) lets you trigger this Actor on any cron interval. Daily refreshes keep your downstream sanctions and PEP databases in sync automatically.

***

### 🌟 Beyond business use cases

Sanctions and PEP data powers more than commercial workflows. The same structured records support research, education, civic projects, and personal initiatives.

<table>
<tr>
<td width="50%">

#### 🎓 Research and academia

- Quantitative studies on sanctions effectiveness over time
- Network graphs of designated entities for political-science papers
- Reproducible PEP datasets for governance and corruption research
- Open-data exercises in regulatory and compliance courses

</td>
<td width="50%">

#### 🎨 Personal and creative

- Portfolio dashboards visualising designations by country
- Side projects mapping sanctioned vessels on a globe
- Educational explainers about how sanctions regimes interact
- Hobbyist OSINT investigations and timeline visualisations

</td>
</tr>
<tr>
<td width="50%">

#### 🤝 Non-profit and civic

- Watchdog tracking of debarred suppliers in public procurement
- Civic transparency around PEPs and conflict-of-interest checks
- Investigative reporting on enablers of sanctioned regimes
- NGO due-diligence screening for grant recipients and partners

</td>
<td width="50%">

#### 🧪 Experimentation

- Train entity-resolution and alias-matching ML models
- Prototype agent pipelines that screen names against watchlists
- Validate fintech compliance product hypotheses with real data
- Stress-test transaction-monitoring rules with realistic feeds

</td>
</tr>
</table>

***

### 🤖 Ask an AI assistant about this scraper

Open a ready-to-send prompt about this ParseForge actor in the AI of your choice:

- 💬 [**ChatGPT**](https://chat.openai.com/?q=How%20do%20I%20use%20the%20OpenSanctions%20Entities%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🧠 [**Claude**](https://claude.ai/new?q=How%20do%20I%20use%20the%20OpenSanctions%20Entities%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🔍 [**Perplexity**](https://perplexity.ai/search?q=How%20do%20I%20use%20the%20OpenSanctions%20Entities%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🅒 [**Copilot**](https://copilot.microsoft.com/?q=How%20do%20I%20use%20the%20OpenSanctions%20Entities%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)

***

### ❓ Frequently Asked Questions

#### 🧩 How does it work?

Pick a collection and optional filters in the input form, click Start, and the Actor streams the consolidated catalogue, applies your filters, and emits a clean structured record per entity. No browser automation, no captchas, no setup.

#### 📏 How accurate is the data?

Each record inherits the accuracy of the issuing authority (OFAC, EU FSF, UN, UK HMT, and so on). The catalogue normalises aliases and identifiers across regimes, but you should always verify a hit against the original `sourceUrls` link before taking commercial or legal action.

#### 🔁 How often is the dataset refreshed?

The OpenSanctions catalogue is updated continuously as source authorities publish new designations. Every run of this Actor pulls the latest consolidated snapshot.

#### 🛡️ Which sanctions lists are included?

Major regimes such as U.S. OFAC SDN, EU Financial Sanctions Files, UK HMT, UN Security Council, Australia DFAT, Canada SEMA, plus dozens of national lists. Use the `datasetSource` filter to scope to a single source slug like `us_ofac_sdn`.

#### 🏛️ Does it include politically exposed persons (PEPs)?

Yes. Set `dataset` to `peps` for the consolidated PEP register, including heads of state, ministers, judges, diplomats, and relatives or close associates (RCAs).

#### 🚢 Are vessels, aircraft, and crypto wallets covered?

Yes. Set the `schema` filter to `Vessel`, `Airplane`, or `CryptoWallet` to restrict to those entity types. Vessel records include IMO numbers; crypto wallets include the chain and address.

#### ⏰ Can I schedule regular runs?

Yes. Use Apify Schedules to run this Actor on any cron interval (hourly, daily, weekly) and keep a downstream sanctions database in sync.

#### ⚖️ Is this data legal to use?

OpenSanctions publishes under a permissive open-data licence that explicitly supports compliance and research use. Review the licence terms for your specific application, but consolidated watchlist metadata is generally public.

#### 💼 Can I use this data commercially?

Yes. The catalogue is published under an open licence that permits commercial use. You remain responsible for complying with the licence and with any downstream regulatory requirements in your own product or jurisdiction.

#### 💳 Do I need a paid Apify plan to use this Actor?

No. The free Apify plan is enough for testing and small runs (10 records per run). A paid plan lifts the limit and gives you scheduling, higher concurrency, and larger datasets.

#### 🔁 What happens if a run fails or gets interrupted?

Apify automatically retries transient errors. If a run still fails, you can inspect the log in the Runs tab, fix the input, and re-run. Partial datasets from failed runs are preserved so you never lose progress.

#### 🆘 What if I need help?

Our support team is here to help. Contact us through the Apify platform or use the Tally form linked below.

***

### 🔌 Integrate with any app

OpenSanctions Scraper connects to any cloud service via [Apify integrations](https://apify.com/integrations):

- [**Make**](https://docs.apify.com/platform/integrations/make) - Automate multi-step compliance workflows
- [**Zapier**](https://docs.apify.com/platform/integrations/zapier) - Connect with 5,000+ apps
- [**Slack**](https://docs.apify.com/platform/integrations/slack) - Get hit alerts in your channels
- [**Airbyte**](https://docs.apify.com/platform/integrations/airbyte) - Pipe sanctions data into your warehouse
- [**GitHub**](https://docs.apify.com/platform/integrations/github) - Trigger runs from commits and releases
- [**Google Drive**](https://docs.apify.com/platform/integrations/drive) - Export datasets straight to Sheets

You can also use webhooks to trigger downstream actions when a run finishes. Push fresh designations into your screening engine, or alert your compliance team in Slack.

***

### 🔗 Recommended Actors

- [**🇬🇧 GOV.UK Content Search Scraper**](https://apify.com/parseforge/govuk-content-search-scraper) - Search the entire UK government publications catalogue
- [**🏛️ UK Parliament Members Scraper**](https://apify.com/parseforge/members-uk-parliament-scraper) - MPs and Lords with biographies, committees, and contact details
- [**🏢 SEC EDGAR Full-Text Search Scraper**](https://apify.com/parseforge/sec-edgar-full-text-search-scraper) - Search U.S. company filings by keyword and form type
- [**🛡️ FINRA BrokerCheck Scraper**](https://apify.com/parseforge/finra-brokercheck-scraper) - U.S. broker disclosures and disciplinary history
- [**🏛️ Florida Sunbiz Business Registry Scraper**](https://apify.com/parseforge/sunbiz-florida-business-scraper) - Florida corporate registry records

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for more reference-data scrapers.

***

**🆘 Need Help?** [**Open our contact form**](https://tally.so/r/BzdKgA) to request a new scraper, propose a custom data project, or report an issue.

***

> **⚠️ Disclaimer:** this Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by OpenSanctions or any of the issuing authorities whose lists it consolidates. All trademarks mentioned are the property of their respective owners. Only publicly available open watchlist data is collected.

# Actor input Schema

## `dataset` (type: `string`):

Which OpenSanctions collection to pull from. 'sanctions' is the consolidated global sanctions list; 'peps' covers politically-exposed persons; 'crime' covers wanted lists; 'default' is the full union of all collections.

## `schema` (type: `string`):

Restrict to a single entity type. Leave empty to include all types.

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

Filter to entities tied to a specific country (lowercase 2-letter code, e.g. 'ru', 'ir', 'kp', 'us'). Leave empty for all countries.

## `topic` (type: `string`):

Restrict to entities flagged with a specific risk topic. Leave empty for all topics.

## `nameQuery` (type: `string`):

Match on the canonical name or any alias. Substring match is case-insensitive; fuzzy match also strips diacritics, punctuation and casing variations. Leave empty to skip name filtering.

## `nameMatchMode` (type: `string`):

How to match the Name Filter against entity names and aliases.

## `datasetSource` (type: `string`):

Restrict to a single underlying source list. Leave empty for all sources within the chosen collection.

## `maxAliases` (type: `integer`):

Cap the aliases array per record to keep payloads compact. Some entities have hundreds of transliteration variants.

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

## Actor input object example

```json
{
  "dataset": "sanctions",
  "schema": "",
  "country": "",
  "topic": "",
  "nameQuery": "",
  "nameMatchMode": "substring",
  "datasetSource": "",
  "maxAliases": 50,
  "maxItems": 10
}
```

# Actor output Schema

## `overview` (type: `string`):

Overview of scraped data

## `fullData` (type: `string`):

Complete dataset

# 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 = {
    "country": "",
    "nameQuery": "",
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/opensanctions-entities-scraper").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 = {
    "country": "",
    "nameQuery": "",
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/opensanctions-entities-scraper").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 '{
  "country": "",
  "nameQuery": "",
  "maxItems": 10
}' |
apify call parseforge/opensanctions-entities-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "OpenSanctions Sanctions & PEP Entities Scraper",
        "description": "Scrape OpenSanctions: 280k+ sanctioned people, companies, vessels and PEPs across 250+ global watchlists. Filter by topic, country, entity type or dataset. Returns names, aliases, identifiers, addresses, sectors, programmes — for AML, KYC and due diligence.",
        "version": "0.0",
        "x-build-id": "OrqewQA0hx8ItXjfV"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~opensanctions-entities-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-opensanctions-entities-scraper",
                "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/parseforge~opensanctions-entities-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-opensanctions-entities-scraper",
                "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/parseforge~opensanctions-entities-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-opensanctions-entities-scraper",
                "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",
                "properties": {
                    "dataset": {
                        "title": "Dataset Collection",
                        "enum": [
                            "sanctions",
                            "peps",
                            "crime",
                            "debarment",
                            "default"
                        ],
                        "type": "string",
                        "description": "Which OpenSanctions collection to pull from. 'sanctions' is the consolidated global sanctions list; 'peps' covers politically-exposed persons; 'crime' covers wanted lists; 'default' is the full union of all collections.",
                        "default": "sanctions"
                    },
                    "schema": {
                        "title": "Entity Type",
                        "enum": [
                            "",
                            "Person",
                            "Organization",
                            "Company",
                            "LegalEntity",
                            "Vessel",
                            "Airplane",
                            "Position",
                            "CryptoWallet"
                        ],
                        "type": "string",
                        "description": "Restrict to a single entity type. Leave empty to include all types.",
                        "default": ""
                    },
                    "country": {
                        "title": "Country (ISO 3166-1 alpha-2)",
                        "type": "string",
                        "description": "Filter to entities tied to a specific country (lowercase 2-letter code, e.g. 'ru', 'ir', 'kp', 'us'). Leave empty for all countries.",
                        "default": ""
                    },
                    "topic": {
                        "title": "Topic Filter",
                        "enum": [
                            "",
                            "sanction",
                            "sanction.linked",
                            "role.pep",
                            "role.rca",
                            "role.judge",
                            "role.diplo",
                            "role.spy",
                            "role.oligarch",
                            "crime",
                            "crime.fin",
                            "crime.terror",
                            "crime.traffick",
                            "crime.cyber",
                            "crime.fraud",
                            "debarment",
                            "wanted",
                            "asset.frozen"
                        ],
                        "type": "string",
                        "description": "Restrict to entities flagged with a specific risk topic. Leave empty for all topics.",
                        "default": ""
                    },
                    "nameQuery": {
                        "title": "Name Filter",
                        "type": "string",
                        "description": "Match on the canonical name or any alias. Substring match is case-insensitive; fuzzy match also strips diacritics, punctuation and casing variations. Leave empty to skip name filtering.",
                        "default": ""
                    },
                    "nameMatchMode": {
                        "title": "Name Match Mode",
                        "enum": [
                            "substring",
                            "fuzzy"
                        ],
                        "type": "string",
                        "description": "How to match the Name Filter against entity names and aliases.",
                        "default": "substring"
                    },
                    "datasetSource": {
                        "title": "Specific Source List",
                        "enum": [
                            "",
                            "us_ofac_sdn",
                            "us_ofac_cons",
                            "eu_fsf",
                            "eu_meps",
                            "gb_hmt_sanctions",
                            "gb_fcdo_sanctions",
                            "un_sc_sanctions",
                            "ch_seco_sanctions",
                            "ca_sema_sanctions",
                            "au_dfat_sanctions",
                            "jp_mof_sanctions",
                            "interpol_red_notices",
                            "wikidata_peps",
                            "everypolitician",
                            "world_bank_debarment",
                            "us_sam_exclusions",
                            "ru_acf_bribetakers",
                            "ru_navalny35"
                        ],
                        "type": "string",
                        "description": "Restrict to a single underlying source list. Leave empty for all sources within the chosen collection.",
                        "default": ""
                    },
                    "maxAliases": {
                        "title": "Max Aliases per Entity",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Cap the aliases array per record to keep payloads compact. Some entities have hundreds of transliteration variants.",
                        "default": 50
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
