# OFAC Sanctions Intelligence MCP (`andrew_avina/ofac-sanctions-mcp`) Actor

Real-time OFAC SDN sanctions screening for AI assistants, compliance workflows, and KYC pipelines.

- **URL**: https://apify.com/andrew\_avina/ofac-sanctions-mcp.md
- **Developed by:** [Andrew Avina](https://apify.com/andrew_avina) (community)
- **Categories:** MCP servers, Business
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

$3.00 / 1,000 result item returneds

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/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

## ofac-sanctions-mcp

**Real-time OFAC SDN sanctions screening for AI assistants, compliance workflows, and KYC pipelines.**

[![Apify Actor](https://img.shields.io/badge/Apify-Actor-brightgreen)](https://apify.com/store)
[![Data Source](https://img.shields.io/badge/Data-US%20Treasury%20OFAC-orange)](https://www.treasury.gov/ofac/)
[![Category](https://img.shields.io/badge/Category-Compliance%20%2F%20AML-purple)](https://apify.com/store)
[![MCP Ready](https://img.shields.io/badge/MCP-Server%20Ready-red)](https://modelcontextprotocol.io)
[![No API Key](https://img.shields.io/badge/API%20Key-Not%20Required-success)](https://apify.com/store)

---

### What Is This?

The US Treasury Office of Foreign Assets Control (OFAC) maintains the **Specially Designated Nationals (SDN) list** — a roster of individuals, companies, vessels, and aircraft that US persons and businesses are legally prohibited from transacting with. The list currently contains over **13,000 designated entries** across dozens of sanctions programs: IRAN, RUSSIA, CUBA, DPRK, SDGT (global terrorism), UKRAINE-EO13661, VENEZUELA, SYRIA, BELARUS, and many more.

Every financial institution, fintech company, law firm, e-commerce platform, and business that touches US dollars must screen counterparties against the SDN list before transacting. Failure to comply carries civil penalties of up to $1 million per violation and potential criminal liability. Most companies either pay $10,000–$50,000/year for enterprise sanctions screening platforms or manually query the OFAC website — which provides no API and no programmatic access.

This actor downloads the official OFAC SDN list XML at startup, parses all 13,000+ entries into structured records with names, aliases, programs, addresses, and ID numbers, and exposes three MCP tools for real-time search and fuzzy-match screening. In MCP server mode, an AI assistant like Claude can screen any entity in milliseconds without leaving the conversation. In batch mode, push results to a dataset for pipeline integration.

No API key required. The OFAC SDN list is a public US government publication.

---

### Who Uses This

**Fintech Compliance Teams**
You're building a KYC onboarding flow and need to screen every new user against the SDN list before account approval. This actor's `screen_entity` tool returns fuzzy match scores so you can build risk-tiered review queues — exact matches get auto-rejected, partial matches go to manual review, clean results get auto-approved. Integrate via MCP into your AI-assisted compliance workflow.

**AML/BSA Officers at Banks and Credit Unions**
You're reviewing a wire transfer to an entity with an ambiguous name. You need to know if "Mahan Air Cargo LLC" appears on the SDN list under any program, with any alias variation. The `screen_entity` tool runs a similarity search across all 13,000 entries and returns scored matches in under a second — faster than logging into the OFAC website.

**Legal Due Diligence Teams at Law Firms**
You're advising on an M&A transaction and need to screen the target company's principals, board members, and major shareholders against OFAC. This actor processes a batch of names in sequence and returns structured results you can attach to your due diligence memo. Integrate into a Claude workflow for automated first-pass screening.

**Venture Capital and Private Equity Firms**
Before wiring a capital call or closing an investment, screen the LP list and investment target executives against OFAC. A sanctioned LP or founder creates instant regulatory exposure. One call to `screen_entity` per name, results logged to your dataset, review flags surfaced to your compliance officer.

**E-Commerce and Marketplace Platforms**
You need to screen sellers, buyers, and payment recipients before processing transactions. The `search_sanctions` tool can check a company name or vessel name against the full SDN list in real time, returning matches with their programs, aliases, and listed addresses for manual review.

**Investigative Journalists and Policy Researchers**
You're tracking which Russian oligarchs are on the OFAC list and what assets they have designated. Filter by program `RUSSIA` to get all designated Russian entities. Filter by type `vessel` to see all sanctioned ships. Filter by type `aircraft` to see all blocked planes.

---

### Key Features

| Feature | Detail |
|---|---|
| Data source | Official OFAC SDN list XML — US Treasury (public domain) |
| Dataset size | 13,000+ SDN entries across all programs |
| Coverage | Individuals, entities, vessels, aircraft |
| Programs | IRAN, RUSSIA, CUBA, DPRK, SDGT, UKRAINE, VENEZUELA, SYRIA, BELARUS, and 40+ more |
| Search | Substring keyword search across names, aliases, remarks, title |
| Fuzzy screening | SequenceMatcher similarity scoring (0.0–1.0) across all names and aliases |
| Filters | Entity type, sanction program, keyword |
| Screening results | POSSIBLE_MATCH (≥85% similarity), PARTIAL_MATCH (≥75%) |
| MCP server mode | Live tool-use in Claude Desktop, Claude Code, any MCP client |
| Batch mode | One-shot runs with dataset output |
| No API key | OFAC data is public — no registration or credentials required |
| XML parsing | Built-in Python xml.etree.ElementTree — no external XML dependencies |

---

### Quick Start

#### Batch Mode — Screen a Single Name

**Input:**
```json
{
  "screenName": "Vladimir Putin",
  "limit": 20
}
````

**Output:**

```json
[
  {
    "uid": "6315",
    "name": "PUTIN, Vladimir Vladimirovich",
    "type": "individual",
    "programs": ["UKRAINE-EO13661", "RUSSIA-EO14024"],
    "aliases": ["ПУТИН, Владимир Владимирович"],
    "addresses": ["Moscow, Russia"],
    "similarity_score": 0.891,
    "is_match": true,
    "screening_result": "POSSIBLE_MATCH",
    "source": "ofac_sdn_list"
  }
]
```

#### Batch Mode — Search by Program

**Input:**

```json
{
  "program": "IRAN",
  "entityType": "entity",
  "limit": 25
}
```

**Output:**

```json
[
  {
    "uid": "4151",
    "name": "BANK MELLI IRAN",
    "type": "entity",
    "programs": ["IRAN", "IFSR"],
    "aliases": ["MELLI BANK", "NATIONAL BANK OF IRAN"],
    "addresses": ["Tehran, Iran", "Dubai, United Arab Emirates"],
    "uid": "4151",
    "source": "ofac_sdn_list"
  },
  ...
]
```

#### MCP Server Mode

**Claude Desktop** (`claude_desktop_config.json`):

```json
{
  "mcpServers": {
    "ofac-sanctions": {
      "command": "npx",
      "args": [
        "apify-actor-mcp",
        "--actor-id", "your-username/ofac-sanctions-mcp",
        "--token", "apify_api_YOURTOKEN"
      ]
    }
  }
}
```

Then ask Claude: *"Screen 'Mahan Air' against the OFAC SDN list and tell me what programs it's designated under."*

***

### MCP Tools Exposed

#### `search_sanctions`

Search the OFAC SDN list by name/keyword, entity type, or sanction program. Returns matching entries with full metadata.

**Arguments:**
| Field | Type | Required | Description |
|---|---|---|---|
| `query` | string | No | Name or keyword to search across names, aliases, remarks |
| `entity_type` | string | No | Filter: `individual`, `entity`, `vessel`, `aircraft` |
| `program` | string | No | Filter by program: `IRAN`, `RUSSIA`, `CUBA`, `DPRK`, etc. |
| `limit` | integer | No | Max results (default 20, max 200) |

**Example call:**

```json
{
  "name": "search_sanctions",
  "arguments": {
    "query": "Hezbollah",
    "entity_type": "entity",
    "limit": 10
  }
}
```

***

#### `get_sanction_programs`

List all active OFAC sanction programs with entity counts. No arguments required.

**Example response:**

```json
[
  {"program": "SDGT", "entity_count": 1847},
  {"program": "IRAN", "entity_count": 1203},
  {"program": "RUSSIA", "entity_count": 987},
  {"program": "DPRK", "entity_count": 412},
  {"program": "CUBA", "entity_count": 389},
  {"program": "UKRAINE-EO13661", "entity_count": 267},
  ...
]
```

***

#### `screen_entity`

Fuzzy-match a name against the entire SDN list using string similarity. Returns scored matches with screening result classification.

**Arguments:**
| Field | Type | Required | Description |
|---|---|---|---|
| `name` | string | Yes | Full name of person or entity to screen |
| `threshold` | number | No | Minimum similarity score 0.0–1.0 (default 0.75) |

**Screening results:**

- `POSSIBLE_MATCH` — similarity ≥ 0.85 (high confidence, requires immediate review)
- `PARTIAL_MATCH` — similarity 0.75–0.84 (moderate confidence, flag for review)
- No result — similarity < threshold (clean)

**Example call:**

```json
{
  "name": "screen_entity",
  "arguments": {
    "name": "Bank Melli Iran",
    "threshold": 0.80
  }
}
```

***

### Input Schema

| Field | Type | Default | Description |
|---|---|---|---|
| `query` | string | `""` | Keyword search across names, aliases, remarks |
| `entityType` | string | `""` | Filter: `individual`, `entity`, `vessel`, `aircraft` |
| `program` | string | `""` | Sanction program filter (IRAN, RUSSIA, CUBA, etc.) |
| `screenName` | string | `""` | Run fuzzy screening for this name (takes priority over `query`) |
| `limit` | integer | `50` | Max results in batch mode (max 500) |
| `serveMcp` | boolean | `false` | Start MCP server instead of batch run |

***

### Use Case Recipes

#### Recipe 1: Automated KYC Name Screening Pipeline

Screen a list of new user names from your onboarding queue:

**Step 1** — Run batch actor with `screenName` set to each user's full name.
**Step 2** — Check `screening_result` field: `POSSIBLE_MATCH` → auto-reject, `PARTIAL_MATCH` → queue for manual review, null → auto-approve.
**Step 3** — Log results to your compliance audit trail.

**Input:**

```json
{
  "screenName": "Ali Hassan Al-Moayad",
  "limit": 20
}
```

#### Recipe 2: Russia Sanctions Intelligence Brief

Get a full list of designated Russian entities for executive briefing:

```json
{
  "program": "RUSSIA",
  "entityType": "entity",
  "limit": 500
}
```

Combine with `UKRAINE-EO13661`, `UKRAINE-EO13685`, and `RUSSIA-EO14024` program filters to capture all Russia-related designations.

#### Recipe 3: Vessel Sanctions Check for Shipping

Before accepting a cargo booking, screen the vessel name:

```json
{
  "screenName": "EVER GIVEN",
  "entityType": "vessel"
}
```

Returns any vessel by that name (or similar) on the SDN list with IMO numbers, flag state, and programs.

#### Recipe 4: Counterparty Due Diligence for M\&A

Screen all named executives in a target company's SEC filing:

```json
{
  "query": "Kim Jong",
  "entityType": "individual",
  "limit": 50
}
```

Run once per principal. Use `threshold: 0.85` in `screen_entity` for conservative screening.

#### Recipe 5: Global Terrorism (SDGT) Research

Get all entities designated under the Specially Designated Global Terrorist program:

```json
{
  "program": "SDGT",
  "limit": 500
}
```

***

### Connecting to Claude Desktop / Claude Code

**macOS Claude Desktop** (`~/Library/Application Support/Claude/claude_desktop_config.json`):

```json
{
  "mcpServers": {
    "ofac-sanctions": {
      "command": "npx",
      "args": [
        "apify-actor-mcp",
        "--actor-id", "your-username/ofac-sanctions-mcp",
        "--token", "apify_api_YOURTOKEN"
      ],
      "env": {}
    }
  }
}
```

**Windows Claude Desktop** (`%APPDATA%\Claude\claude_desktop_config.json`):
Same JSON as above.

**Claude Code** (project `.claude/settings.json`):

```json
{
  "mcpServers": {
    "ofac-sanctions": {
      "command": "npx",
      "args": ["apify-actor-mcp", "--actor-id", "your-username/ofac-sanctions-mcp", "--token", "apify_api_YOURTOKEN"]
    }
  }
}
```

**Cursor / Windsurf / any MCP client:**
Point at the running actor's URL: `http://<run-url>:4321`

- `GET /mcp/tools` — list available tools
- `POST /mcp/call` — invoke a tool with `{"name": "...", "arguments": {...}}`

***

### Data Source and Legal Notes

- **Source:** US Treasury Office of Foreign Assets Control (OFAC) — `https://www.treasury.gov/ofac/`
- **File:** SDN List XML (`sdn.xml`) — downloaded fresh at each actor startup
- **Update frequency:** OFAC publishes SDN list updates irregularly — sometimes multiple times per day during active designation periods. This actor fetches the list fresh on each run, so batch runs reflect the current list.
- **Legal disclaimer:** This actor provides informational access to public OFAC data. It is not a substitute for a certified compliance screening system. Organizations with regulatory sanctions screening obligations should consult qualified legal counsel and use certified screening solutions for their primary compliance programs. Results from this actor should be used as supplemental intelligence only.
- **Public domain:** The OFAC SDN list is a US government publication in the public domain — no license or attribution required.

***

### Technical Architecture

The actor operates in two modes controlled by the `serveMcp` input flag:

**Batch mode (default):**

1. Download SDN XML from `https://www.treasury.gov/ofac/downloads/sdn.xml` (~5MB)
2. Parse all `<sdnEntry>` elements using Python's built-in `xml.etree.ElementTree`
3. Build in-memory list of 13,000+ structured dicts
4. Apply filters (query / type / program) or run fuzzy screen
5. Push results to Apify default dataset
6. Store program summary in key-value store

**MCP server mode:**

1. Same download and parse as batch
2. Start async HTTP server on port 4321
3. Expose `/mcp/tools` (GET) and `/mcp/call` (POST)
4. Push first 100 entries to dataset for inspection
5. Run until actor is stopped (max 24h)

**Fuzzy matching algorithm:**
Uses Python's `difflib.SequenceMatcher` for O(n) similarity scoring across all 13,000 entries and their aliases. For a single name screen, this completes in under 200ms in-memory. No external fuzzy-match libraries required.

**XML namespace handling:**
OFAC SDN XML may include a namespace URI. The parser auto-detects the namespace from the root tag and applies it consistently to all child element queries — no hardcoded namespace strings that would break on format changes.

***

### Pricing

| Volume | Price |
|---|---|
| First 1,000 results | $0.25 |
| 1,001 – 50,000 results | $0.20/1k |
| MCP server (per session-hour) | Metered by result count |

**ROI context:** Enterprise sanctions screening platforms (Dow Jones, Refinitiv World-Check, LexisNexis) cost $20,000–$100,000/year. A single compliance analyst spending 30 minutes per counterparty on manual OFAC checks costs $75/hr × 0.5hr = $37.50 per check. This actor returns the same information in under 2 seconds.

***

### Support

- **Issues:** File a GitHub issue on the actor repository
- **Apify Community:** [community.apify.com](https://community.apify.com)
- **OFAC official source:** [treasury.gov/ofac](https://www.treasury.gov/ofac/)
- **OFAC SDN Search (manual):** [sanctionssearch.ofac.treas.gov](https://sanctionssearch.ofac.treas.gov/)
- **Enterprise compliance:** Contact via Apify actor page

# Actor input Schema

## `query` (type: `string`):

Search for an entity name or keyword across the OFAC SDN list (name, aliases, remarks). Examples: 'Russia Bank', 'Kim Jong', 'Hezbollah', 'Wagner'. Leave empty to return all entries up to the limit.

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

Filter by SDN entity type. 'individual' = persons, 'entity' = organizations/companies, 'vessel' = ships, 'aircraft' = planes. Leave empty to search all types.

## `program` (type: `string`):

Filter by OFAC sanction program. Examples: 'IRAN', 'RUSSIA', 'CUBA', 'DPRK', 'SDGT' (Global Terrorism), 'UKRAINE-EO13661', 'VENEZUELA'. Use get\_sanction\_programs tool to see all active programs.

## `screenName` (type: `string`):

Run a fuzzy name-match screen against the full SDN list. Enter a person or company name to check if it matches any SDN entry. Returns similarity scores and screening results. Takes priority over keyword search.

## `limit` (type: `integer`):

Maximum number of SDN records to return in batch mode (max 500). In MCP server mode, the full dataset (~13,000+ entries) is loaded into memory for real-time queries.

## `serveMcp` (type: `boolean`):

When enabled, starts an MCP-compatible HTTP server on port 4321 instead of returning a batch dataset. Use this mode to connect Claude Desktop, Cursor, or any MCP client directly to OFAC sanctions data. The actor will run continuously until stopped.

## Actor input object example

```json
{
  "query": "",
  "entityType": "",
  "program": "",
  "screenName": "",
  "limit": 50,
  "serveMcp": false
}
```

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("andrew_avina/ofac-sanctions-mcp").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("andrew_avina/ofac-sanctions-mcp").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 '{}' |
apify call andrew_avina/ofac-sanctions-mcp --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "OFAC Sanctions Intelligence MCP",
        "description": "Real-time OFAC SDN sanctions screening for AI assistants, compliance workflows, and KYC pipelines.",
        "version": "0.1",
        "x-build-id": "3pkjOBciCYVNJhkSb"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/andrew_avina~ofac-sanctions-mcp/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-andrew_avina-ofac-sanctions-mcp",
                "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/andrew_avina~ofac-sanctions-mcp/runs": {
            "post": {
                "operationId": "runs-sync-andrew_avina-ofac-sanctions-mcp",
                "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/andrew_avina~ofac-sanctions-mcp/run-sync": {
            "post": {
                "operationId": "run-sync-andrew_avina-ofac-sanctions-mcp",
                "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": {
                    "query": {
                        "title": "Name / Keyword Search",
                        "type": "string",
                        "description": "Search for an entity name or keyword across the OFAC SDN list (name, aliases, remarks). Examples: 'Russia Bank', 'Kim Jong', 'Hezbollah', 'Wagner'. Leave empty to return all entries up to the limit.",
                        "default": ""
                    },
                    "entityType": {
                        "title": "Entity Type Filter",
                        "enum": [
                            "",
                            "individual",
                            "entity",
                            "vessel",
                            "aircraft"
                        ],
                        "type": "string",
                        "description": "Filter by SDN entity type. 'individual' = persons, 'entity' = organizations/companies, 'vessel' = ships, 'aircraft' = planes. Leave empty to search all types.",
                        "default": ""
                    },
                    "program": {
                        "title": "Sanction Program Filter",
                        "type": "string",
                        "description": "Filter by OFAC sanction program. Examples: 'IRAN', 'RUSSIA', 'CUBA', 'DPRK', 'SDGT' (Global Terrorism), 'UKRAINE-EO13661', 'VENEZUELA'. Use get_sanction_programs tool to see all active programs.",
                        "default": ""
                    },
                    "screenName": {
                        "title": "Entity Screening Name",
                        "type": "string",
                        "description": "Run a fuzzy name-match screen against the full SDN list. Enter a person or company name to check if it matches any SDN entry. Returns similarity scores and screening results. Takes priority over keyword search.",
                        "default": ""
                    },
                    "limit": {
                        "title": "Result Limit",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of SDN records to return in batch mode (max 500). In MCP server mode, the full dataset (~13,000+ entries) is loaded into memory for real-time queries.",
                        "default": 50
                    },
                    "serveMcp": {
                        "title": "MCP Server Mode",
                        "type": "boolean",
                        "description": "When enabled, starts an MCP-compatible HTTP server on port 4321 instead of returning a batch dataset. Use this mode to connect Claude Desktop, Cursor, or any MCP client directly to OFAC sanctions data. The actor will run continuously until stopped.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
