# Sanctions List Screening API: EU, UN, OFAC SDN, UK (`actose/ecb-style-eu-sanctions-list`) Actor

Bulk-screen people and companies against official EU, UN, OFAC SDN and UK sanctions lists: fuzzy match score, matched alias, programs, birth dates, source link, new-listing alerts. No API key, no login. MCP-ready for AI agents. Pay per result, no monthly rental. $3 per 1,000 names screened.

- **URL**: https://apify.com/actose/ecb-style-eu-sanctions-list.md
- **Developed by:** [ABM](https://apify.com/actose) (community)
- **Categories:** AI, Developer tools
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.55 / 1,000 name screeneds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/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 List Screening API: EU, UN, OFAC SDN & UK name check

**$3 per 1,000 names screened ($0.003 per name). No subscription, no API key, no login.** Blank, duplicate and invalid
inputs are free, and so is any run where an official list could not be downloaded.

This Actor screens people and companies in bulk against the **official consolidated sanctions lists**:

| Key | List | Publisher |
|---|---|---|
| `eu` | EU consolidated list of persons, groups and entities subject to financial sanctions (FSF) | European Commission |
| `un` | UN Security Council Consolidated List | United Nations |
| `ofac` | Specially Designated Nationals and Blocked Persons (SDN) | US Treasury, OFAC |
| `ofac-nonsdn` | OFAC consolidated non-SDN lists (SSI, NS-MBS, CAPTA…) | US Treasury, OFAC |
| `uk` | UK Sanctions List (the only official UK list since 28 January 2026) | UK FCDO |

For each name it uses **fuzzy matching** (transliteration, word order, legal suffixes such as LLC / OOO / GmbH, typos)
and returns a **0–1 score**, the alias that matched, the sanctions programmes, dates of birth, nationalities, listing
date and a link to the official record. A **new listings** mode reports people and entities added to the lists, for
daily schedules.

### What you get

- One dataset row per screened name: `status` (`match` / `possibleMatch` / `noMatch`), `topScore`, `matchCount`, best match, and the list of `matches`.
- Each match carries `list`, `listId`, `referenceNumber`, `name`, `matchedAlias`, `score`, `matchType`, `entityType`, `programs`, `listedOn`, `birthDates`, `nationalities`, `countries`, `remarks` and `sourceUrl`.
- `listVersions`: the publication date of each list you were checked against, which you can keep as audit evidence.
- `summary`: a one-sentence plain-text verdict, ready to pass to an LLM or paste into a case note.
- A CSV report (`screening-report.csv`, one row per match) in the run's key-value store.
- Names in any script work: Latin, Cyrillic (`Евгений Пригожин`), Arabic, Chinese… The input and every list alias are compared both in their original script and transliterated to Latin.

### How much does it cost?

Pay per event: **`screening-checked` = $0.003** for each unique name screened against the lists, whether it is
clear or a hit, because a "no match" is the compliance evidence you need. **`new-listing-found` = $0.003** for each new
listing reported in monitoring mode.

| Volume | Price |
|---|---|
| 100 names (one supplier onboarding batch) | $0.30 |
| 1,000 names | **$3.00** |
| 10,000 customers, rescreened monthly | $30.00 per month |
| Daily new-listings alert, ~20 new listings per week | about $0.25 per month |

There is no monthly rental. Blank lines, duplicates (`wagner group` = `Wagner Group`) and inputs with no letters or
digits are skipped for free. If a selected list cannot be downloaded, the run stops and nothing is charged (see
`failOnListError`). The Actor respects your maximum charge per run: it stops cleanly when the budget is used up and
never returns unpaid results.

### Input

```json
{
  "mode": "screen",
  "names": ["Wagner Group", "Acme Trading LLC", "Евгений Пригожин"],
  "lists": ["eu", "un", "ofac"],
  "threshold": 0.85,
  "entityType": "any",
  "maxMatchesPerName": 5
}
```

| Field | Default | Meaning |
|---|---|---|
| `mode` | `screen` | `screen` = check names; `newListings` = report recent additions to the lists |
| `names` / `namesText` | – | names to screen (array, or one per line pasted from a spreadsheet) |
| `lists` | `eu, un, ofac` | any of `eu`, `un`, `ofac`, `ofac-nonsdn`, `uk` |
| `threshold` | `0.85` | minimum score (1.0 = exact name only, 0.75 = broad) |
| `entityType` | `any` | `person`, `entity` (organisations, vessels, aircraft) or `any` |
| `maxMatchesPerName` | `5` | best records returned per name |
| `onlyNew` | `false` | scheduled runs: only names with a match not seen before, or only listings added since the last run |
| `newListingsDays` | `7` | new listings mode: EU / UN / UK records listed in the last N days |
| `stateKey` | `default` | separate memory for each schedule or portfolio |
| `cacheHours` | `6` | reuse lists already downloaded in your account for this many hours (0 = always download) |
| `failOnListError` | `true` | stop at no charge if a list is unavailable, instead of screening against the other lists |

### Output (one screened name)

```json
{
  "recordType": "screening",
  "inputName": "Wagner Group",
  "normalizedName": "wagner group",
  "status": "match",
  "topScore": 1.0,
  "matchCount": 2,
  "bestMatchName": "Wagner Group",
  "bestMatchList": "eu",
  "bestMatchPrograms": ["RUS", "LBY"],
  "matches": [
    {
      "list": "eu",
      "listId": "7383",
      "referenceNumber": "EU.7383.42",
      "name": "Wagner Group",
      "matchedAlias": "Wagner Group",
      "score": 1.0,
      "matchType": "exact",
      "entityType": "entity",
      "programs": ["RUS", "LBY"],
      "listedOn": "2021-12-13",
      "birthDates": [],
      "nationalities": [],
      "countries": ["RUSSIAN FEDERATION"],
      "remarks": "Unincorporated Russia-based private military entity…",
      "sourceUrl": "https://eur-lex.europa.eu/legal-content/EN/TXT/?uri=…",
      "isNew": null
    },
    {
      "list": "ofac",
      "listId": "25393",
      "name": "PMC WAGNER",
      "matchedAlias": "WAGNER GROUP",
      "score": 1.0,
      "matchType": "exact",
      "entityType": "entity",
      "programs": ["UKRAINE-EO13660", "RUSSIA-EO14024"],
      "sourceUrl": "https://sanctionssearch.ofac.treas.gov/Details.aspx?id=25393"
    }
  ],
  "listsChecked": ["eu", "un", "ofac"],
  "listsFailed": [],
  "incomplete": false,
  "listVersions": {"eu": "2026-10-23", "un": "2026-10-22", "ofac": "2026-10-20"},
  "threshold": 0.85,
  "checkedAt": "2026-10-24T08:00:00Z",
  "summary": "Wagner Group: match - 2 record(s) scored >= 0.85. Best: \"Wagner Group\" on EU (RUS, LBY), score 1.0, via alias \"Wagner Group\"."
}
```

(Values shown are illustrative; IDs and dates come from the live lists.)

A clear name looks like this: `{"inputName": "Acme Trading LLC", "status": "noMatch", "topScore": 0.0, "matchCount": 0, "matches": [], "summary": "Acme Trading LLC: no match >= 0.85 in EU, UN, OFAC (versions: eu=2026-10-23, un=2026-10-22, ofac=2026-10-20)."}`

A new listing (mode `newListings`):

```json
{
  "recordType": "newListing",
  "list": "eu",
  "listId": "171234",
  "name": "Example Shipping Ltd",
  "aliases": ["Example Shipping Ltd", "ООО Пример Шиппинг"],
  "entityType": "entity",
  "programs": ["RUS"],
  "listedOn": "2026-10-21",
  "reason": "listedWithinDays",
  "sourceUrl": "https://eur-lex.europa.eu/…",
  "summary": "New on EU (listedWithinDays): Example Shipping Ltd [entity], programs RUS, listed 2026-10-21."
}
```

### Use cases

#### 1. KYC onboarding at a payment company: screen every new merchant

A **compliance analyst at a fintech or payment institution** screens the 50 to 300 merchants and beneficial owners
signed up each day before they are activated.

Input:

```json
{"names": ["Sovcomflot", "Ivan Petrov", "Brightline Logistics FZE", "Alisher Usmanov"], "lists": ["eu", "un", "ofac", "uk"], "threshold": 0.85, "maxMatchesPerName": 3}
```

Result extract:

```json
[{"inputName": "Alisher Usmanov", "status": "match", "topScore": 1.0, "bestMatchList": "eu", "bestMatchPrograms": ["UKR"]},
 {"inputName": "Brightline Logistics FZE", "status": "noMatch", "matchCount": 0}]
```

Next step: `noMatch` merchants are activated automatically. `match` and `possibleMatch` rows go to a manual review queue
together with `birthDates` and `nationalities` so the analyst can rule out a namesake. The `listVersions` field is
stored in the customer file as evidence. 300 merchants a day ≈ $0.90 a day.

#### 2. Export control: check freight buyers and consignees before shipping

A **trade compliance officer at an industrial exporter** checks the 1,200 buyers, consignees and freight forwarders in
the ERP every month, including vessels.

Input:

```json
{"namesText": "Rosoboronexport\nIran Shipping Lines\nMahan Air\nGlobal Parts Trading GmbH", "lists": ["eu", "un", "ofac", "ofac-nonsdn"], "entityType": "entity", "threshold": 0.88}
```

Result extract:

```json
[{"inputName": "Mahan Air", "status": "match", "bestMatchList": "ofac", "bestMatchPrograms": ["SDGT", "IFSR"]},
 {"inputName": "Global Parts Trading GmbH", "status": "noMatch"}]
```

Next step: the CSV report (`screening-report.csv`) is attached to the monthly export-control audit file, and any order
for a matched party is blocked in the ERP. 1,200 parties a month = $3.60.

#### 3. Daily watch: alert the team when the EU or OFAC adds new names

The **head of AML at a bank or crypto exchange** wants a Slack message every morning listing the people and entities
sanctioned the day before, plus re-screening of the 20,000-customer base each night where only new hits are reported.

Input of the morning alert (scheduled daily):

```json
{"mode": "newListings", "lists": ["eu", "un", "ofac", "uk"], "onlyNew": true, "stateKey": "daily-alert"}
```

Input of the nightly re-screening (only new hits are delivered and paid for):

```json
{"names": ["…20,000 customer names…"], "lists": ["eu", "un", "ofac", "uk"], "onlyNew": true, "stateKey": "customer-base", "threshold": 0.9}
```

Result extract:

```json
[{"recordType": "newListing", "list": "ofac", "name": "EXAMPLE TRADING CO LTD", "programs": ["RUSSIA-EO14024"], "reason": "notInPreviousSnapshot"}]
```

Next step: n8n sends each row's `summary` to Slack, and a match against the customer base opens a ticket in the case
management tool. With about 30 new listings a week, the alert costs about $0.40 a month. The first run of each `stateKey`
only saves a baseline and is free.

#### 4. Due diligence by an AI agent

A **lawyer or M\&A analyst** asks Claude: "Are the shareholders of this target company sanctioned anywhere?" The agent
calls the Actor through MCP with the five shareholder names and gets back the `summary` field of each name, with the
official links to cite.

### Use with AI agents (MCP)

The Actor is MCP-ready for Claude, Cursor, ChatGPT and any agent that can call an MCP server:

```
https://mcp.apify.com/?actors=<username>/ecb-style-eu-sanctions-list
```

Each result has a plain-text `summary`, and every match carries a `sourceUrl`, so agents can explain and cite their
answer. A clear name has `status: "noMatch"` and a summary stating which list versions were checked.

### API examples

**Python**

```python
from apify_client import ApifyClient

client = ApifyClient("<APIFY_TOKEN>")
run = client.actor("<username>/ecb-style-eu-sanctions-list").call(run_input={
    "names": ["Wagner Group", "Acme Trading LLC"],
    "lists": ["eu", "un", "ofac"],
    "threshold": 0.85,
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["inputName"], item["status"], item["topScore"], item["bestMatchName"])
```

**JavaScript**

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

const client = new ApifyClient({ token: '<APIFY_TOKEN>' });
const run = await client.actor('<username>/ecb-style-eu-sanctions-list').call({
    names: ['Wagner Group', 'Acme Trading LLC'],
    lists: ['eu', 'un', 'ofac'],
    threshold: 0.85,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((i) => console.log(i.inputName, i.status, i.topScore));
```

**HTTP (synchronous, returns the results directly)**

```
POST https://api.apify.com/v2/acts/<username>~ecb-style-eu-sanctions-list/run-sync-get-dataset-items?token=<APIFY_TOKEN>
{"names": ["Wagner Group"], "lists": ["eu", "un", "ofac"]}
```

### Integrations (Make, Zapier, n8n, Google Sheets)

- **n8n**: Schedule Trigger (daily 07:00) → *Apify: Run Actor* with `{"mode": "newListings", "onlyNew": true, "stateKey": "daily-alert"}` → *Apify: Get dataset items* → *Slack: Send message* with `{{$json.summary}}`.
- **Make**: *Google Sheets: Watch rows* (new customer) → *Apify: Run an Actor* (synchronous) with `{"names": ["{{name}}"]}` → *Router*: `status = noMatch` → mark the customer approved; otherwise → email the compliance team.
- **Zapier**: *New row in Google Sheets* → *Apify: Run Actor* → *Filter* `status` is not `noMatch` → *Gmail / Teams*.
- **Google Sheets**: export the dataset as CSV or use the Apify Google Sheets integration to append the results to a sheet.

### How matching works

1. Names are normalised: case, accents, punctuation, word order, and legal forms (LLC, Ltd, GmbH, OOO, JSC, FZE…) are ignored.
2. Each name is compared in its original script **and** transliterated to Latin (Cyrillic, Greek, Arabic, Chinese…).
3. Score = best of: exact match (1.0), character similarity of the sorted words (catches typos and transliteration variants), and "all words found in a longer alias" (0.85–0.95, e.g. `Prigozhin` → `Yevgeniy Viktorovich PRIGOZHIN`).
4. `status`: `match` if the top score is ≥ 0.97, `possibleMatch` if it is between your threshold and 0.97, `noMatch` otherwise.

### FAQ

**Where does the data come from?** Directly from the official files published by the European Commission (FSF), the UN
Security Council, the US Treasury (OFAC Sanctions List Service) and the UK FCDO. No third-party aggregator is used.

**How fresh is it?** The lists are downloaded at run time. With the default `cacheHours: 6`, runs in your account within
6 hours reuse the copy already downloaded and parsed. Every result states the version (`listVersions`) it was checked against.

**Do I pay for names that are clear?** Yes: each unique name screened costs $0.003 whatever the outcome, because "not
on any list as of version X" is the result you file. Duplicates, blank lines and failed runs are free.

**Can I reduce false positives?** Raise `threshold` to 0.9–0.95, set `entityType`, and compare `birthDates` /
`nationalities` before escalating.

**Does it replace a compliance officer?** No. It finds candidate matches; a person must confirm them. A fuzzy match is
not a legal determination.

**Is UK OFSI supported?** The OFSI Consolidated List closed on 28 January 2026. Use `uk`, the FCDO UK Sanctions List
that replaced it.

### Limitations

- OFAC files do not publish a listing date: in `newListings` mode, OFAC additions are found by comparing with the previous run's snapshot (the first run sets the baseline).
- The checks cover sanctions lists only. PEP lists, adverse media and ownership rules (such as OFAC's 50% rule) are not included.
- Matching is name-based. Dates of birth and nationalities are returned for your review but are not used in the score.
- Very short or very common single words (e.g. `Bank`) can return many possible matches.
- If an official site is down, the run fails at no charge. With `failOnListError: false`, the run continues on the lists that loaded and every result is flagged `incomplete: true`.
- The actor runs in 512 MB by default. If you select all five lists (including `uk` and `ofac-nonsdn`) and the run runs out of memory, raise the run memory to 1024 MB.

### En français : filtrage des listes de sanctions UE, ONU, OFAC

Cet Actor vérifie en masse des noms de personnes ou de sociétés contre la **liste consolidée des sanctions financières
de l'UE**, la liste du Conseil de sécurité de l'ONU, la liste OFAC SDN et la liste britannique. Il sert au **contrôle
de gel des avoirs** (LCB-FT, KYC, criblage de tiers, conformité export). La correspondance est approximative (translittération,
ordre des mots, formes juridiques) et chaque nom reçoit un score de 0 à 1. Prix : 0,003 $ par nom criblé.

Entrée : `{"names": ["Groupe Wagner", "Société Exemple SARL"], "lists": ["eu", "un", "ofac"], "threshold": 0.85}`

Résultat : `{"inputName": "Groupe Wagner", "status": "possibleMatch", "topScore": 0.96, "bestMatchName": "Wagner Group", "bestMatchList": "eu", "listVersions": {"eu": "2026-10-23"}}`

Le mode `newListings` programmé chaque jour signale les nouvelles inscriptions sur les listes (mesures restrictives UE, ONU, OFAC). Le registre national des gels
de la DG Trésor n'est pas couvert, mais il reprend en grande partie les mesures UE et ONU.

# Actor input Schema

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

<b>screen</b>: check each name below against the selected sanctions lists (1 result per name). <b>newListings</b>: report people and entities recently added to the lists (ideal for a daily schedule); the names field is ignored.

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

One person or organisation per line, in any script (Latin, Cyrillic, Arabic, Chinese...). Examples: 'Wagner Group', 'Vladimir Putin', 'Acme Trading LLC'. Duplicates and blank lines are skipped for free.

## `namesText` (type: `string`):

Optional: paste a column from Excel / Google Sheets, one name per line. Added to the list above.

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

Official lists to check. eu = EU Financial Sanctions Files (FSF) consolidated list; un = UN Security Council consolidated list; ofac = US Treasury OFAC SDN list; ofac-nonsdn = OFAC consolidated non-SDN lists (SSI, NS-MBS, CAPTA...); uk = UK Sanctions List (FCDO).

## `threshold` (type: `number`):

Minimum similarity score for a list record to be returned as a match. 1.0 = exact name only, 0.85 = recommended (catches transliterations and small typos), 0.75 = broad (more false positives).

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

Restrict matches to persons or to organisations (entities, vessels, aircraft). 'any' checks everything.

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

Maximum number of list records returned for each screened name (best scores first).

## `onlyNew` (type: `boolean`):

Screen mode: output (and pay for) only names that have a match not seen in previous runs with the same state key. New listings mode: report only records added since the previous run's snapshot (the first run just saves the snapshot).

## `newListingsDays` (type: `integer`):

New listings mode: report EU, UN and UK records listed in the last N days (OFAC files publish no listing date; OFAC additions are detected by comparison with the previous run). 0 = only use the snapshot comparison.

## `stateKey` (type: `string`):

Name of the memory used by 'Only new' and by new-listings snapshots. Use a different key for each schedule or customer portfolio.

## `cacheHours` (type: `integer`):

Official lists are downloaded, parsed and kept in your account's 'sanctions-lists-cache' store. Runs within this window reuse that copy (faster, cheaper). 0 = always download a fresh copy. The list version used is reported in every result (listVersions).

## `failOnListError` (type: `boolean`):

Recommended for compliance. If one selected list is unavailable the run stops and nothing is charged. If off, names are screened against the lists that loaded and each result is flagged incomplete: true.

## Actor input object example

```json
{
  "mode": "screen",
  "names": [
    "Wagner Group",
    "Acme Trading LLC"
  ],
  "lists": [
    "eu",
    "un",
    "ofac"
  ],
  "threshold": 0.85,
  "entityType": "any",
  "maxMatchesPerName": 5,
  "onlyNew": false,
  "newListingsDays": 7,
  "stateKey": "default",
  "cacheHours": 6,
  "failOnListError": true
}
```

# Actor output Schema

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

No description

## `report` (type: `string`):

No description

## `summary` (type: `string`):

No description

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

Main results as a table (dataset view).

# 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 = {
    "mode": "screen",
    "names": [
        "Wagner Group",
        "Acme Trading LLC"
    ],
    "lists": [
        "eu",
        "un",
        "ofac"
    ],
    "threshold": 0.85
};

// Run the Actor and wait for it to finish
const run = await client.actor("actose/ecb-style-eu-sanctions-list").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 = {
    "mode": "screen",
    "names": [
        "Wagner Group",
        "Acme Trading LLC",
    ],
    "lists": [
        "eu",
        "un",
        "ofac",
    ],
    "threshold": 0.85,
}

# Run the Actor and wait for it to finish
run = client.actor("actose/ecb-style-eu-sanctions-list").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 '{
  "mode": "screen",
  "names": [
    "Wagner Group",
    "Acme Trading LLC"
  ],
  "lists": [
    "eu",
    "un",
    "ofac"
  ],
  "threshold": 0.85
}' |
apify call actose/ecb-style-eu-sanctions-list --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,actose/ecb-style-eu-sanctions-list"
        }
    }
}
```

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/GxCM0jkdteSL6C52c/builds/PnbCP0eh8yd3PFZ9e/openapi.json