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

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

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

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/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

## Sanctions & Watchlist Screening — for AI Agents, KYC & AML

Screen any **person or company name** against the world's major **sanctions and watchlists** in one call. Give this Actor a list of names and it returns, for each one, whether it matches a sanctioned party — with a **risk score**, the **sanctions programs**, **aliases**, **dates of birth**, **nationalities** and the **source list** behind every match.

Built for **AI agents, KYC/AML onboarding, compliance tooling, and due-diligence** — clean, structured, machine-readable output with zero setup and no API keys.

---

### Why this Actor?

Sanctions data is scattered across half a dozen government websites, each in its own awkward format — one ships CSV, another XML, another splits names and aliases across separate files. Keeping a live, unified, searchable copy is real work. And an LLM can't do this from memory: sanctions lists change **weekly**, and a wrong answer here is a compliance failure.

This Actor does that work for you. It pulls the latest official lists at run time, unifies them into one clean schema, and fuzzy-matches your names against every alias and spelling — including transliterations (e.g. *Wagner* ↔ *Vagner*, Cyrillic ↔ Latin).

- **KYC / AML onboarding** — screen new customers, suppliers or counterparties before you do business.
- **AI agent compliance tool** — let an agent check a name in real time via MCP and get back a structured verdict.
- **Ongoing monitoring** — re-screen your book of clients on a schedule as lists change.
- **Due diligence & investigations** — check the people and entities behind a deal against global sanctions.

Because the sources are public and this runs keyless, screening is **fast and cheap**, and always reflects the **current** lists.

---

### What it screens against

The Actor aggregates the major official, publicly-published sanctions lists:

| Source | Coverage |
| --- | --- |
| **US OFAC** | Specially Designated Nationals (SDN) + Consolidated list |
| **European Union** | EU consolidated financial sanctions list |
| **United Nations** | UN Security Council Consolidated List |
| **UK OFSI** | UK consolidated list of financial sanctions targets |

Together that's **30,000+ sanctioned people, companies and vessels**, refreshed from source on every run so you always screen against the latest designations. You can screen against all of them or pick a subset.

---

### What you get

For every name you submit, the Actor returns one record:

| Field | Description |
| --- | --- |
| `query` | The name you screened |
| `isMatch` | Whether any match was found (`true` / `false`) |
| `riskLevel` | `none`, `low`, `medium` or `high` — based on best match confidence |
| `matchCount` | How many matches were found |
| `topScore` | Confidence of the best match (0–100) |
| `topMatchName` | Name of the best match |
| `topMatchSource` | Which list it came from (OFAC / EU / UN / UK) |
| `topMatchType` | Person / Entity / Vessel |
| `topMatchPrograms` | Sanctions programs (e.g. `RUSSIA-EO14024`, `DPRK3`) |
| `topMatchListedOn` | Designation date |
| `matchesSummary` | Human-readable summary of all matches |
| `matches` | Full array of matches, each with score, source, programs, aliases, dates of birth, nationalities, addresses and a source link |
| `screenedAt` | Screening timestamp |

The `matches` array is the detailed payload an agent or compliance system consumes; the flat `topMatch*` fields make the result easy to scan in a spreadsheet.

---

### Example output

```json
{
  "query": "Vladimir Putin",
  "isMatch": "true",
  "riskLevel": "high",
  "matchCount": "3",
  "topScore": "100",
  "topMatchName": "PUTIN, Vladimir Vladimirovich",
  "topMatchSource": "OFAC",
  "topMatchType": "Person",
  "topMatchPrograms": "RUSSIA-EO14024",
  "topMatchListedOn": "",
  "matchesSummary": "PUTIN, Vladimir Vladimirovich (100%, OFAC: RUSSIA-EO14024) | Владимир Владимирович ПУТИН (100%, EU: UKR) | Vladimir Vladimirovich PUTIN (100%, UK: Russia)",
  "matches": [
    {
      "name": "PUTIN, Vladimir Vladimirovich",
      "score": 100,
      "source": "OFAC",
      "type": "Person",
      "programs": ["RUSSIA-EO14024"],
      "nationalities": [],
      "birthDates": [],
      "aliases": [],
      "sourceId": "...",
      "sourceUrl": "https://sanctionssearch.ofac.treas.gov/"
    }
  ],
  "screenedAt": "2026-07-06T15:00:00.000Z"
}
````

A clean name returns `isMatch: "false"`, `riskLevel: "none"` — a positive "all clear".

***

### Input

| Field | Type | Default | Description |
| --- | --- | --- | --- |
| `queries` | array | — | **Required.** Names of people or companies to screen. |
| `minScore` | integer | `85` | Minimum match confidence (0–100). Lower = more matches but more noise. |
| `entityType` | string | `all` | Restrict to `person`, `entity`, or `vessel`. |
| `sources` | array | all | Which lists to use: `OFAC`, `EU`, `UN`, `UK`. |
| `country` | string | — | Only return matches linked to this country / nationality. |
| `maxMatchesPerQuery` | integer | `10` | Max matches to return per name. |

#### Example input

```json
{
  "queries": ["Vladimir Putin", "Wagner Group", "Acme Trading LLC", "Jane Smith"],
  "minScore": 85,
  "sources": ["OFAC", "EU", "UN", "UK"]
}
```

#### Screening a whole customer list

```json
{
  "queries": ["Customer One Ltd", "John A. Doe", "Global Imports SA", "..."],
  "minScore": 88,
  "entityType": "all",
  "maxMatchesPerQuery": 5
}
```

***

### How matching works

Sanctions screening is deliberately **recall-first**: it is far worse to miss a real sanctioned party than to surface a name that later turns out to be a different person. So the Actor:

1. **Normalizes** every name — case, punctuation and accents are stripped, so *Kadyrov*, *Kadýrov* and *КАДЫРОВ* all line up.
2. **Matches against every alias**, not just the primary name, including transliterations and alternate spellings.
3. **Scores** each candidate 0–100 using token and edit-distance similarity, and keeps those at or above your `minScore`.

Because of this, **common names (e.g. "Maria Garcia", "James Wilson") can produce high-scoring matches** even when your person is not the sanctioned one — simply because someone by that name is on a list. That's expected. Use the returned **dates of birth, nationalities, programs and source links** to confirm or dismiss a match.

**Tuning tips:**

- Raise `minScore` (e.g. 90–95) to cut noise when you screen common names.
- Add a `country` filter when you know the nationality.
- Pass `entityType` to separate people from companies.
- Include middle names / full legal names for sharper matches.

***

### How to use it

1. Click **Try for free**.
2. Paste the names into `queries`.
3. Click **Start**.
4. Read the results as **JSON, CSV, or Excel**, or via the Apify API.

A run screening 100 names against all four lists finishes in seconds.

***

### Calling from the API

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

Then fetch the dataset:

```bash
curl "https://api.apify.com/v2/acts/YOUR_ACTOR_ID/runs/last/dataset/items?token=YOUR_APIFY_TOKEN"
```

The Actor also integrates with webhooks, Zapier, Make, and n8n, so you can wire screening straight into your onboarding flow.

***

### Use cases in detail

#### 1. Customer & supplier onboarding (KYC/KYB)

Screen every new client, vendor or beneficial owner at onboarding. Feed the whole batch in one run and route any `riskLevel` of `medium`/`high` to a human reviewer.

#### 2. AI compliance agents

Expose this as a tool to an AI agent so it can screen a name mid-conversation — "is this counterparty sanctioned?" — and get back structured, sourced results it can reason over.

#### 3. Ongoing / periodic re-screening

Sanctions lists change constantly. Re-run your customer base on a schedule and catch newly-designated parties.

#### 4. Transaction & trade compliance

Check parties to a payment, shipment or contract against sanctions before it goes through.

#### 5. Investigations & journalism

Quickly check whether the people and companies behind a deal, property or network appear on any sanctions list.

***

### Output formats

Every run produces a dataset you can export as **JSON**, **JSON Lines**, **CSV**, **Excel**, **HTML**, or **RSS**, or pull via the Apify API into your own systems.

***

### Frequently asked questions

**Which lists are covered?**
US OFAC (SDN + Consolidated), the European Union consolidated list, the UN Security Council Consolidated List, and the UK OFSI list — 30,000+ targets in total.

**How fresh is the data?**
It's pulled from the official sources on every run, so you always screen against the current lists.

**Does it match aliases and other spellings?**
Yes — it matches against all known aliases and handles accents and transliterations (Latin ↔ Cyrillic, etc.).

**Why did a clearly-innocent name get a match?**
Because someone with a similar name is on a list. Screening is recall-first by design. Confirm identity using the dates of birth, nationalities and programs in the result.

**Can I screen thousands of names at once?**
Yes. Batch them all into `queries` — the lists are loaded once per run and every name is checked against them.

**Can an AI agent call this automatically?**
Yes — it's callable as a tool through Apify's agent/MCP integrations, returning structured JSON.

***

### Important — responsible use & disclaimer

This Actor aggregates **publicly available** sanctions and watchlist data published by government bodies, and provides **potential name matches for informational purposes only**.

- It is **not legal, compliance, or financial advice**, and it is **not a substitute for a qualified compliance program**.
- Matches are **name-based** and may include **false positives** (different people who share a name) or, in rare cases, miss records due to source gaps or spelling variance.
- **Always verify** a potential match against dates of birth, identifiers, and the official source list before making any decision about a person or business.
- You are responsible for using the results in line with applicable laws and regulations in your jurisdiction.

Data originates from official government sources (US OFAC, EU, UN, UK OFSI), which remain the authoritative references.

***

### Support

Want another list added (e.g. a national regime), or a field exposed differently? Open an issue from the Actor's page. Screen smart, stay compliant.

# Actor input Schema

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

Names of people or companies to screen against sanctions lists, e.g. \["Vladimir Putin", "Acme Trading LLC"].

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

Only return matches at or above this confidence (0-100). Lower = more matches but more noise. 85 is a good default for screening.

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

Restrict matches to a given type.

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

Which official lists to screen against. Leave empty for all.

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

Only return matches linked to this country/nationality (name or ISO code). Leave empty for all.

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

Maximum number of matches to return for each screened name.

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

Apify Proxy settings. The official sources are public, so a proxy is OFF by default.

## Actor input object example

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

# Actor output Schema

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

The screened name

## `isMatch` (type: `string`):

Whether any sanctions match was found

## `riskLevel` (type: `string`):

none / low / medium / high

## `matchCount` (type: `string`):

Number of matches

## `topScore` (type: `string`):

Best match score (0-100)

## `topMatchName` (type: `string`):

Name of the best match

## `topMatchSource` (type: `string`):

List of the best match

## `topMatchType` (type: `string`):

Person / Entity / Vessel

## `topMatchPrograms` (type: `string`):

Sanctions programs of the best match

## `topMatchListedOn` (type: `string`):

Designation date of the best match

## `matchesSummary` (type: `string`):

Human-readable summary of all matches

## `screenedAt` (type: `string`):

Screening timestamp

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "queries": [
        "Vladimir Putin",
        "Wagner Group",
        "Nicolas Maduro"
    ],
    "minScore": 85,
    "sources": [
        "OFAC",
        "EU",
        "UN",
        "UK"
    ],
    "maxMatchesPerQuery": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("haketa/sanctions-screening").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "queries": [
        "Vladimir Putin",
        "Wagner Group",
        "Nicolas Maduro",
    ],
    "minScore": 85,
    "sources": [
        "OFAC",
        "EU",
        "UN",
        "UK",
    ],
    "maxMatchesPerQuery": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("haketa/sanctions-screening").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 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 '{
  "queries": [
    "Vladimir Putin",
    "Wagner Group",
    "Nicolas Maduro"
  ],
  "minScore": 85,
  "sources": [
    "OFAC",
    "EU",
    "UN",
    "UK"
  ],
  "maxMatchesPerQuery": 10
}' |
apify call haketa/sanctions-screening --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "AML & Sanctions Screening for AI Agents (OFAC, EU, UN, UK)",
        "description": "Screen any name or company against global sanctions & watchlists (OFAC SDN, EU, UN, UK OFSI) for KYC/AML. Fuzzy name matching with risk scores, programs, aliases, dates of birth & source lists. Real-time compliance grounding for AI agents & LLMs.",
        "version": "0.1",
        "x-build-id": "0BGF86XTJlnYdvqgN"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/haketa~sanctions-screening/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-haketa-sanctions-screening",
                "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/haketa~sanctions-screening/runs": {
            "post": {
                "operationId": "runs-sync-haketa-sanctions-screening",
                "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/haketa~sanctions-screening/run-sync": {
            "post": {
                "operationId": "run-sync-haketa-sanctions-screening",
                "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",
                "required": [
                    "queries"
                ],
                "properties": {
                    "queries": {
                        "title": "Names to screen",
                        "type": "array",
                        "description": "Names of people or companies to screen against sanctions lists, e.g. [\"Vladimir Putin\", \"Acme Trading LLC\"].",
                        "items": {
                            "type": "string"
                        }
                    },
                    "minScore": {
                        "title": "Minimum match score",
                        "minimum": 40,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Only return matches at or above this confidence (0-100). Lower = more matches but more noise. 85 is a good default for screening.",
                        "default": 85
                    },
                    "entityType": {
                        "title": "Entity type",
                        "enum": [
                            "all",
                            "person",
                            "entity",
                            "vessel"
                        ],
                        "type": "string",
                        "description": "Restrict matches to a given type.",
                        "default": "all"
                    },
                    "sources": {
                        "title": "Sanctions sources",
                        "type": "array",
                        "description": "Which official lists to screen against. Leave empty for all.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "OFAC",
                                "EU",
                                "UN",
                                "UK"
                            ],
                            "enumTitles": [
                                "US OFAC (SDN + Consolidated)",
                                "European Union",
                                "United Nations",
                                "UK OFSI"
                            ]
                        },
                        "default": [
                            "OFAC",
                            "EU",
                            "UN",
                            "UK"
                        ]
                    },
                    "country": {
                        "title": "Country filter (optional)",
                        "type": "string",
                        "description": "Only return matches linked to this country/nationality (name or ISO code). Leave empty for all."
                    },
                    "maxMatchesPerQuery": {
                        "title": "Max matches per name",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of matches to return for each screened name.",
                        "default": 10
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify Proxy settings. The official sources are public, so a proxy is OFF by default.",
                        "default": {
                            "useApifyProxy": 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
