# Financial Crime Screening · AML for BI + Pipelines (`ryanclinton/financial-crime-screening`) Actor

AML/CFT composite screening as a scheduled Apify actor. Same deterministic engine as the MCP twin, dataset-output shape. For Zapier / Make / n8n / BI tools and scheduled bulk re-screening. 16 sources. 6 institutional policy profiles. $0.30 per result.

- **URL**: https://apify.com/ryanclinton/financial-crime-screening.md
- **Developed by:** [Ryan Clinton](https://apify.com/ryanclinton) (community)
- **Categories:** AI, Developer tools
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-usage

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

## Financial Crime Screening

**Deterministic AML risk classification as a scheduled-execution Apify actor.**

Same engine, same envelope, same data sources as the [MCP twin](https://apify.com/ryanclinton/financial-crime-screening-mcp) — but exposed as an Apify actor that pushes one result per entity to its dataset, instead of a Streamable HTTP MCP server. Built for the enterprise orchestration + batch intelligence layer: Zapier, Make, n8n, BI tools that consume Apify datasets directly, scheduled bulk re-screening cycles, and pipelines without Claude Desktop / Cursor / Cline access.

### In one sentence

A deterministic AML compliance engine that produces replayable, machine-actionable risk classifications as Apify dataset rows.

### In one paragraph

Financial Crime Screening is AI-native compliance infrastructure exposed as a scheduled Apify actor. 16 live data sources, 5-dimensional scoring, six named institutional policy profiles, caller-supplied custom rules, regulatory obligations with deadlines, operational restrictions for downstream banking systems, AI autonomy contracts, and `decisionAuditId` for regulatory replay. Same primitives the MCP twin exposes — but as one row per entity in your Apify dataset, ready to ingest into Zapier / Make / n8n / BI tools.

### When to use this vs the MCP

| You want | Use |
|---|---|
| AI agent (Claude Desktop, Cursor, Cline) makes one call at a time | [financial-crime-screening-mcp](https://apify.com/ryanclinton/financial-crime-screening-mcp) |
| Zapier / Make / n8n pipeline consumes results | This actor |
| Scheduled bulk re-screening of an entity portfolio | This actor |
| BI tool ingests Apify datasets directly | This actor |
| Webhook-driven async event flow | This actor |
| Real-time / one-off per-entity decision | The MCP twin |

Both actors share the exact same scoring engine, envelope, policy system, evidence triad, decision primitives, and audit-replay infrastructure. The only difference is the transport layer.

### Core guarantees

- Same input always produces the same verdict (deterministic)
- No LLM in the scoring path (regulator-explainable)
- Every decision is replayable via `decisionAuditId`
- Every action is machine-actionable through stable enums
- Automation branches on enums and booleans, never on free-text prose
- Every finding cites a regulatory source and carries an auditable URL

### Designed for

- banks (BSA-regulated US, UK FCA, EU credit institutions)
- crypto exchanges (FinCEN MSB, NYDFS Part 504, MiCA-regulated)
- money service businesses / remittance firms
- fund administrators (LP onboarding, hedge fund KYC)
- fintechs and embedded-finance platforms
- payment processors and card issuers
- EU AMLR Article 6 obliged entities
- compliance automation teams running on Zapier / Make / n8n
- regulatory technology vendors building on top of primary-source data

### Input

```json
{
  "entity": "Meridian Trade & Finance LLC",
  "policy_profile": "bsa_bank_us"
}
````

Bulk mode (up to 100 entities per run):

```json
{
  "entities": [
    { "entity_name": "Meridian Trade & Finance LLC", "entity_type": "company", "country": "VG" },
    { "entity_name": "Acme Holdings Ltd", "entity_type": "company", "country": "GB" },
    { "entity_name": "Viktor Petrov", "entity_type": "individual", "country": "RU" }
  ],
  "policy_profile": "crypto_exchange_us"
}
```

With custom policy rules:

```json
{
  "entity": "Acme Holdings LLC",
  "policy_profile": "standard",
  "custom_policy_rules": [
    {
      "name": "Block any FATF black-list jurisdiction",
      "when": { "condition": "fatf_flag_equals", "value": "BLACK" },
      "then": { "action": "block", "rationale": "Institutional policy: no exposure to FATF-blacklisted countries." }
    },
    {
      "name": "Enhanced DD on high shell score",
      "when": { "condition": "shell_score_above", "value": 50 },
      "then": { "action": "enhanced_due_diligence", "rationale": "Shell-detection score above policy threshold." }
    }
  ]
}
```

#### Bring your own upstream API keys

| Header / Input field | Source | Where to sign up |
|---|---|---|
| `opensanctions_api_key` | OpenSanctions global sanctions, PEP, watchlist coverage | [opensanctions.org/account/](https://www.opensanctions.org/account/) |
| `opencorporates_api_key` | OpenCorporates 200M+ corporate registry | [opencorporates.com/api\_accounts/new](https://opencorporates.com/api_accounts/new) |
| `dol_api_key` | DOL WHD + EBSA enforcement records | [dataportal.dol.gov/registration](https://dataportal.dol.gov/registration) |
| `fec_api_key` | FEC campaign finance (optional) | [api.open.fec.gov](https://api.open.fec.gov) |

Customer-supplied keys are never stored — they're read once per run from input or env-var fallback and passed through to the relevant sub-actor. If a key is absent, that source is skipped and the response carries a `dataSourceErrors` entry of `missing-credential`.

### Output

One dataset row per entity. Each row carries the full classification envelope including:

- **Risk Layer** — `amlRiskTier`, `riskScore`, `directSanctionsMatch`, `fatfFlag`, `dimensions{}`, `jurisdictionRisk{}`
- **Action Layer** — `decision.recommendedAction`, `decision.urgency`, `decision.escalationPolicy{}`, `obligations[]`, `operationalRestrictions[]`
- **Automation Layer** — `agentInstructions.safeToAutoApprove`, `operationalReadiness.automationSafe`, `autonomyContract.allowedActions[]` / `prohibitedActions[]`, `confidence.recommendedHandling`, `complianceEvents[]`
- **Replay Layer** — `decisionAuditId`, `sourceLineage{}` (per-source snapshot timestamps), `sourceRecordCounts{}`, `policyProfileApplied`
- **Memory + Forecast** — `riskMemory.riskTrend`, `riskMemory.deltaScore30d`, `riskMemory.projectedTier30d`
- **Evidence** — `evidence[]` with severity + dimension + automationImpact triads, source URLs, stable risk codes
- **Run Summary** — `runSummary.elapsedMs`, `runSummary.perSourceStatus{}`, `dataSourceErrors{}`

### Policy profiles

| Profile | Treats FATF grey as | Max shell score | Min SAR tier | Auto-block fuzzy sanctions |
|---|---|---|---|---|
| `standard` | medium | 100 | HIGH | no |
| `crypto_exchange_us` | HIGH | 30 | MEDIUM | no |
| `bsa_bank_us` | HIGH | 50 | HIGH | no |
| `eu_obliged_entity` | HIGH | 40 | MEDIUM | no |
| `msb_remittance_us` | HIGH | 35 | MEDIUM | no |
| `fund_administrator` | medium | 40 | HIGH | no |

### Why deterministic systems matter

Regulators require explainability, replayability, auditability, and stable escalation logic. Probabilistic AI systems (LLM-driven scoring, ML-based AML classifiers, opaque ensembles) struggle with all four because their outputs change over time even when inputs don't.

This actor produces reproducible compliance outcomes from deterministic rules and source evidence. Every score is a pure function of the upstream data plus a versioned rule set. Months later, regulatory examiners replay the exact verdict via `decisionAuditId` — the `evidence[]` array, the `policyEvaluation` block, the `sourceLineage` timestamps, and the dimensional scores all reproduce identically as long as the rule version matches.

### Pricing

| Event | Cost |
|---|---|
| `result-returned` (one classification) | $0.30 |

No subscription, no monthly minimum, no charge for failed runs (no-data + error responses don't trigger billing). Apify's $5/month platform credits cover dozens of classifications. Most compliance teams running 500-2,000 screenings per month spend $150-$600.

### Limitations

- US-centric regulatory coverage. FDIC, CFPB, FEC, FARA, DOL WHD, DOL EBSA, Federal Register are US government sources. Non-US institutions have less coverage.
- OpenSanctions, OpenCorporates, and DOL sources require customer-supplied API keys. Without them, those sources skip with a `missing-credential` `dataSourceErrors` entry.
- 100 entities per run cap. For larger portfolios, dispatch multiple parallel runs or use the MCP twin's `batch_screen` tool.
- Snapshot history retained per actor lifetime (50 snapshots per entity, 1000 decision audit entries total). Mirror to your own retention system for multi-year regulatory record-keeping.
- Fuzzy sanctions matches (confidence 0.50-0.95) always require human review — the actor cannot determine on its own whether a fuzzy match is the same person.
- Not a substitute for FinCEN Form 114 filing or qualified BSA/AML officer judgement. The actor produces audit-ready inputs to compliance workflows; the workflows themselves remain human-supervised.

### Platform ecosystem

| Layer | Tool |
|---|---|
| Agent-native MCP transport | [ryanclinton/financial-crime-screening-mcp](https://apify.com/ryanclinton/financial-crime-screening-mcp) |
| Pipeline / BI dataset transport | This actor |
| Underlying sub-actors | 16 wrapper actors (OFAC, OpenSanctions, Interpol, FBI, FARA, FEC, OpenCorporates, GLEIF, Nonprofit Explorer, SEC EDGAR, SEC Insider, CFPB, FDIC, Federal Register, DOL WHD, DOL EBSA) |

### Responsible use

This actor accesses only publicly available government data and customer-supplied API endpoints. AML screening results are analytical aids, not legal determinations. Compliance decisions must be made by qualified personnel under applicable law. SAR filing obligations and timelines are governed by BSA/FinCEN regulations, not by the recommendation strings returned by this actor.

### Support

Open an issue on the [Apify Store page](https://console.apify.com/actors/) for the actor. For custom integrations, enterprise compliance pipelines, or AI-native compliance infrastructure questions, reach out through the Apify platform.

# Actor input Schema

## `entity` (type: `string`):

Single entity to screen. Use this for one-off screens. For bulk runs, use the `entities` array below instead.

## `entities` (type: `array`):

Bulk screening. Each entry: { entity\_name, entity\_type?, country? }. Capped at 100 per run.

## `policy_profile` (type: `string`):

Institutional risk-tolerance profile applied on top of the base scoring.

## `custom_policy_rules` (type: `array`):

Optional caller-supplied when/then rules layered on top of the named profile. Up to 20 rules per call. See README for the rule grammar.

## `opensanctions_api_key` (type: `string`):

Customer-supplied OpenSanctions key. Get a free trial key at opensanctions.org/account/. Without it, OpenSanctions is skipped.

## `opencorporates_api_key` (type: `string`):

Customer-supplied OpenCorporates key. Get one at opencorporates.com/api\_accounts/new. Without it, OpenCorporates is skipped.

## `dol_api_key` (type: `string`):

Customer-supplied DOL key. Free at dataportal.dol.gov/registration. Without it, DOL WHD + EBSA return dry-run samples.

## `fec_api_key` (type: `string`):

Customer-supplied FEC key. DEMO\_KEY used if blank (1000 req/hr limit).

## Actor input object example

```json
{
  "entity": "Meridian Trade & Finance LLC",
  "entities": [],
  "policy_profile": "standard",
  "custom_policy_rules": []
}
```

# 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 = {
    "entity": "Meridian Trade & Finance LLC",
    "entities": [],
    "custom_policy_rules": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("ryanclinton/financial-crime-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 = {
    "entity": "Meridian Trade & Finance LLC",
    "entities": [],
    "custom_policy_rules": [],
}

# Run the Actor and wait for it to finish
run = client.actor("ryanclinton/financial-crime-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 '{
  "entity": "Meridian Trade & Finance LLC",
  "entities": [],
  "custom_policy_rules": []
}' |
apify call ryanclinton/financial-crime-screening --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Financial Crime Screening · AML for BI + Pipelines",
        "description": "AML/CFT composite screening as a scheduled Apify actor. Same deterministic engine as the MCP twin, dataset-output shape. For Zapier / Make / n8n / BI tools and scheduled bulk re-screening. 16 sources. 6 institutional policy profiles. $0.30 per result.",
        "version": "1.0",
        "x-build-id": "P8Ltx9WYkXKMh1Tip"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/ryanclinton~financial-crime-screening/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-ryanclinton-financial-crime-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/ryanclinton~financial-crime-screening/runs": {
            "post": {
                "operationId": "runs-sync-ryanclinton-financial-crime-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/ryanclinton~financial-crime-screening/run-sync": {
            "post": {
                "operationId": "run-sync-ryanclinton-financial-crime-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",
                "properties": {
                    "entity": {
                        "title": "Entity name (single screen)",
                        "type": "string",
                        "description": "Single entity to screen. Use this for one-off screens. For bulk runs, use the `entities` array below instead."
                    },
                    "entities": {
                        "title": "Entities (bulk screen, up to 100 per run)",
                        "maxItems": 100,
                        "type": "array",
                        "description": "Bulk screening. Each entry: { entity_name, entity_type?, country? }. Capped at 100 per run."
                    },
                    "policy_profile": {
                        "title": "Policy profile",
                        "enum": [
                            "standard",
                            "crypto_exchange_us",
                            "bsa_bank_us",
                            "eu_obliged_entity",
                            "msb_remittance_us",
                            "fund_administrator"
                        ],
                        "type": "string",
                        "description": "Institutional risk-tolerance profile applied on top of the base scoring.",
                        "default": "standard"
                    },
                    "custom_policy_rules": {
                        "title": "Custom policy rules (advanced)",
                        "maxItems": 20,
                        "type": "array",
                        "description": "Optional caller-supplied when/then rules layered on top of the named profile. Up to 20 rules per call. See README for the rule grammar."
                    },
                    "opensanctions_api_key": {
                        "title": "OpenSanctions API key",
                        "type": "string",
                        "description": "Customer-supplied OpenSanctions key. Get a free trial key at opensanctions.org/account/. Without it, OpenSanctions is skipped."
                    },
                    "opencorporates_api_key": {
                        "title": "OpenCorporates API key",
                        "type": "string",
                        "description": "Customer-supplied OpenCorporates key. Get one at opencorporates.com/api_accounts/new. Without it, OpenCorporates is skipped."
                    },
                    "dol_api_key": {
                        "title": "DOL Open Data Portal API key",
                        "type": "string",
                        "description": "Customer-supplied DOL key. Free at dataportal.dol.gov/registration. Without it, DOL WHD + EBSA return dry-run samples."
                    },
                    "fec_api_key": {
                        "title": "FEC API key (optional)",
                        "type": "string",
                        "description": "Customer-supplied FEC key. DEMO_KEY used if blank (1000 req/hr limit)."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
