# NFA BASIC Registrant Scraper (`automation-lab/nfa-basic-registrant-scraper`) Actor

Search NFA BASIC registrants by firm name, individual, pool, or NFA ID. Extract registration status, categories, profile URLs, contact fields, and regulatory action summaries for compliance workflows.

- **URL**: https://apify.com/automation-lab/nfa-basic-registrant-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## NFA BASIC Registrant Scraper

Extract public NFA BASIC registrant data for futures, swaps, commodities, CTA, CPO, FCM, IB, and associated due-diligence workflows.

### What does NFA BASIC Registrant Scraper do?

NFA BASIC Registrant Scraper searches the National Futures Association BASIC registry and saves structured registrant records.

It can search by:

- ✅ Firm name
- ✅ Individual last name and optional first name
- ✅ Pool name
- ✅ Exact NFA ID

Each output row includes identity, registration status, registration categories, contact/location fields when public, profile URL, and regulatory-action summaries when available.

### Who is it for?

This scraper is useful for compliance, risk, and revenue teams that need repeatable NFA BASIC checks.

- 🧾 Compliance analysts verifying futures and swaps counterparties
- 🏦 Broker-dealer and FCM operations teams checking registration categories
- 🔎 Due-diligence providers enriching regulated entity profiles
- 📈 Commodity and fintech sales teams building compliant lead lists
- 🧑‍⚖️ Legal teams reviewing regulatory action histories
- 🧰 Data vendors normalizing NFA BASIC records into internal systems

### Why use this actor?

Manual BASIC searches are slow when you need to check many firms or IDs.

This actor converts the public website workflow into a repeatable API job.

Benefits:

- Structured JSON, CSV, Excel, XML, and Parquet exports
- Direct Apify API access
- Exact NFA profile URLs for audit trails
- Batch search support
- Per-record regulatory-action indicators
- No login required for the public data used by the actor

### Data extracted

| Field | Description |
|---|---|
| `searchType` | firm, individual, pool, or nfaId |
| `searchQuery` | Input query that produced the record |
| `entityType` | Inferred BASIC entity type |
| `nfaId` | Public NFA ID |
| `name` | Registrant name |
| `membershipStatus` | BASIC membership/approval status |
| `registrationTypes` | Current public registration categories |
| `hasRegulatoryActions` | Whether BASIC marks regulatory actions |
| `regulatoryActionCount` | Count exposed in search/profile data |
| `city`, `state`, `country` | Public location data when available |
| `address`, `phone` | Public contact data from profile details |
| `profileUrl` | Direct BASIC profile URL |
| `currentActivities` | Current activity/status questions when exposed |
| `registrationHistory` | Recent registration history lines |
| `regulatoryActions` | Summarized action/outcome details |
| `scrapedAt` | ISO timestamp |

### How much does it cost to scrape NFA BASIC registrants?

This actor uses pay-per-event pricing.

You pay a small start fee per run plus a per-registrant result fee.

The default prefill is intentionally small so first runs are cheap.

For larger compliance batches, use `maxItems` to control the maximum number of saved records.

### How to use NFA BASIC Registrant Scraper

1. Open the actor on Apify.
2. Add one or more `searchQueries`.
3. Choose whether to include detailed profile/background data.
4. Set `maxItems`.
5. Run the actor.
6. Download results from the dataset.

### Input example

```json
{
  "searchQueries": [
    { "type": "firm", "query": "goldman" },
    { "type": "nfaId", "query": "0002014" }
  ],
  "includeDetails": true,
  "maxItems": 100,
  "maxActionsPerRegistrant": 5
}
````

### Input fields

#### `searchQueries`

Main search list.

Each query has:

- `type`: `firm`, `individual`, `nfaId`, or `pool`
- `query`: firm name, last name, pool name, or ID
- `firstName`: optional, only for individual searches

#### `firmNames`

Shortcut list for firm-name searches.

#### `individualLastNames`

Shortcut list for individual last-name searches.

#### `nfaIds`

Shortcut list for exact NFA ID searches.

Numeric IDs are padded to seven digits.

#### `includeDetails`

When enabled, the actor fetches profile details, registration history, current activities, and regulatory-action indexes.

#### `maxItems`

Maximum rows saved across all searches.

#### `maxActionsPerRegistrant`

Caps regulatory-action summaries attached to each registrant row.

### Output example

```json
{
  "searchType": "firm",
  "searchQuery": "goldman",
  "entityType": "firm",
  "nfaId": "0002014",
  "name": "GOLDMAN SACHS & CO LLC",
  "membershipStatus": "NFA Member Approved",
  "registrationTypes": ["Commodity Pool Operator", "Commodity Trading Advisor", "Futures Commission Merchant", "Swap Dealer"],
  "hasRegulatoryActions": true,
  "regulatoryActionCount": 86,
  "city": "NEW YORK",
  "state": "NY",
  "country": "UNITED STATES",
  "profileUrl": "https://www.nfa.futures.org/basicnet/basic-profile.aspx?nfaid=0002014",
  "source": "nfa-basic"
}
```

### Tips for best results

- Use exact NFA IDs when you already have them.
- Use firm names for lead enrichment or broad discovery.
- Use `includeDetails: false` for faster search-only batches.
- Increase `maxActionsPerRegistrant` only when regulatory action detail matters.
- Keep `maxItems` bounded for scheduled monitoring runs.

### Common workflows

#### Counterparty verification

Search an NFA ID before onboarding a commodity, futures, or swaps counterparty.

#### Compliance monitoring

Run the same firm list regularly and compare regulatory-action counts over time.

#### Lead enrichment

Search firm names to add NFA IDs, registration categories, and profile URLs to CRM records.

#### Investigation prep

Export registration history and regulatory action summaries before deeper manual review.

### Integrations

You can connect the dataset to:

- Google Sheets via Apify integrations
- Zapier workflows
- Make scenarios
- Webhooks for monitoring alerts
- Internal compliance databases
- BI tools through API exports

### API usage

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/nfa-basic-registrant-scraper').call({
  searchQueries: [{ type: 'firm', query: 'goldman' }],
  includeDetails: true,
  maxItems: 100
});
console.log(run.defaultDatasetId);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/nfa-basic-registrant-scraper').call(run_input={
    'searchQueries': [{'type': 'nfaId', 'query': '0002014'}],
    'includeDetails': True,
    'maxItems': 10,
})
print(run['defaultDatasetId'])
```

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~nfa-basic-registrant-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"searchQueries":[{"type":"firm","query":"goldman"}],"maxItems":100}'
```

### MCP integration

Use this actor from Claude Desktop, Claude Code, or other MCP clients through Apify MCP.

MCP URL:

```text
https://mcp.apify.com/?tools=automation-lab/nfa-basic-registrant-scraper
```

Claude Code setup:

```bash
claude mcp add apify-nfa-basic "https://mcp.apify.com/?tools=automation-lab/nfa-basic-registrant-scraper"
```

Claude Desktop JSON config:

```json
{
  "mcpServers": {
    "apify-nfa-basic": {
      "url": "https://mcp.apify.com/?tools=automation-lab/nfa-basic-registrant-scraper"
    }
  }
}
```

Example prompts:

- "Search NFA BASIC for Goldman and summarize active registration categories."
- "Verify NFA ID 0002014 and list regulatory action counts."
- "Create a compliance table for these NFA IDs."

### Legality

The actor extracts publicly available registry data from NFA BASIC.

You are responsible for using the data lawfully and respecting applicable compliance, privacy, and contractual requirements.

Do not use the output for unlawful discrimination, harassment, or misleading claims.

### FAQ

#### Is this actor affiliated with NFA?

No. This actor is not affiliated with or endorsed by the National Futures Association.

#### Can I use this for regulated compliance decisions?

Use the output as a structured collection aid and audit trail. Important decisions should still be reviewed against the source BASIC profile and your internal compliance policy.

### Limitations

- The actor depends on the public NFA BASIC website and its JSON-RPC endpoints.
- Some profile fields are unavailable for some registrants.
- Regulatory action details are summaries, not a substitute for legal review.
- The actor does not authenticate into private NFA systems.

### Troubleshooting

#### Why did I get fewer results than expected?

Check `maxItems`. The actor stops when it reaches that limit.

Also try a broader firm name or an exact NFA ID.

#### Why is a field empty?

NFA BASIC does not expose every address, phone, activity, or action field for every registrant.

#### Why are some records duplicated by name?

BASIC can list historical names or related records with the same NFA ID. The actor keeps unique search-result rows for auditability.

### Related scrapers

Explore other Automation Lab actors for compliance, enrichment, and public-records workflows:

- https://apify.com/automation-lab
- https://apify.com/automation-lab/website-contact-finder
- https://apify.com/automation-lab/bulk-url-status-checker

### Changelog

#### 0.1

Initial version with firm, individual, pool, and NFA ID search plus profile details.

### Support

Open an Apify issue on the actor page if the public BASIC site changes or you need additional fields.

### Notes

This actor is not affiliated with or endorsed by the National Futures Association.

It is designed to help users structure public registry lookups into repeatable datasets.

### Example batch ideas

- Daily check of high-risk counterparties
- Weekly update of CPO and CTA lead lists
- One-time enrichment of CRM accounts
- Legal review prep for known NFA IDs
- Vendor onboarding verification
- Commodity trading advisor monitoring
- Futures commission merchant status checks

### Dataset export formats

Apify datasets can be downloaded as:

- JSON
- JSONL
- CSV
- Excel
- XML
- RSS
- Parquet

### Scheduling

Use Apify schedules for recurring monitoring.

For example:

- Daily compliance refresh
- Weekly prospect enrichment
- Monthly regulatory action audit

### Webhook alerts

Configure a webhook after each run to send the dataset ID to your own system.

Your system can then compare current output to previous results.

### Quality controls

Recommended checks:

- Match exact NFA IDs when possible
- Review `profileUrl` for important records
- Treat regulatory-action summaries as flags for follow-up
- Store `scrapedAt` for audit history

### Contact enrichment use case

When a firm profile includes address and phone fields, the actor returns them in structured columns.

This is useful for CRM enrichment, vendor onboarding, and account research.

### Compliance use case

Compliance teams can maintain a list of NFA IDs and run scheduled checks.

The output highlights registration categories and regulatory-action counts for review.

### Due diligence use case

Due-diligence teams can use this actor as a first-pass data collection tool before manual analysis.

The saved profile URL helps reviewers jump back to the source record.

# Actor input Schema

## `searchQueries` (type: `array`):

One or more NFA BASIC searches. Use firm for company names, individual for last names, nfaId for exact IDs, or pool for pool names.

## `firmNames` (type: `array`):

Optional shortcut list of firm names. These are added to Search queries.

## `individualLastNames` (type: `array`):

Optional shortcut list of individual last names.

## `nfaIds` (type: `array`):

Optional shortcut list of exact NFA IDs. Numeric IDs are left-padded to 7 digits.

## `includeDetails` (type: `boolean`):

Fetch profile, registration history, activities, and regulatory action summaries for each registrant.

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

Maximum registrant rows to save across all searches.

## `maxActionsPerRegistrant` (type: `integer`):

Limits the number of detailed regulatory action summaries attached to each output row.

## Actor input object example

```json
{
  "searchQueries": [
    {
      "type": "firm",
      "query": "goldman"
    },
    {
      "type": "nfaId",
      "query": "0002014"
    }
  ],
  "includeDetails": true,
  "maxItems": 20,
  "maxActionsPerRegistrant": 5
}
```

# Actor output Schema

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

No description

# 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 = {
    "searchQueries": [
        {
            "type": "firm",
            "query": "goldman"
        },
        {
            "type": "nfaId",
            "query": "0002014"
        }
    ],
    "includeDetails": true,
    "maxItems": 20,
    "maxActionsPerRegistrant": 5
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/nfa-basic-registrant-scraper").call(input);

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = {
    "searchQueries": [
        {
            "type": "firm",
            "query": "goldman",
        },
        {
            "type": "nfaId",
            "query": "0002014",
        },
    ],
    "includeDetails": True,
    "maxItems": 20,
    "maxActionsPerRegistrant": 5,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/nfa-basic-registrant-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "searchQueries": [
    {
      "type": "firm",
      "query": "goldman"
    },
    {
      "type": "nfaId",
      "query": "0002014"
    }
  ],
  "includeDetails": true,
  "maxItems": 20,
  "maxActionsPerRegistrant": 5
}' |
apify call automation-lab/nfa-basic-registrant-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/nfa-basic-registrant-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "NFA BASIC Registrant Scraper",
        "description": "Search NFA BASIC registrants by firm name, individual, pool, or NFA ID. Extract registration status, categories, profile URLs, contact fields, and regulatory action summaries for compliance workflows.",
        "version": "0.1",
        "x-build-id": "ZIAWd3LMMWgnLFt0f"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~nfa-basic-registrant-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-nfa-basic-registrant-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/automation-lab~nfa-basic-registrant-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-nfa-basic-registrant-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/automation-lab~nfa-basic-registrant-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-nfa-basic-registrant-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "searchQueries"
                ],
                "properties": {
                    "searchQueries": {
                        "title": "Search queries",
                        "type": "array",
                        "description": "One or more NFA BASIC searches. Use firm for company names, individual for last names, nfaId for exact IDs, or pool for pool names.",
                        "items": {
                            "type": "object",
                            "required": [
                                "type",
                                "query"
                            ],
                            "properties": {
                                "type": {
                                    "type": "string",
                                    "enum": [
                                        "firm",
                                        "individual",
                                        "nfaId",
                                        "pool"
                                    ],
                                    "title": "Search type",
                                    "description": "Which BASIC search mode to use."
                                },
                                "query": {
                                    "type": "string",
                                    "title": "Search text or NFA ID",
                                    "description": "Firm name, individual last name, pool name, or NFA ID."
                                },
                                "firstName": {
                                    "type": "string",
                                    "title": "First name (individual search, optional)",
                                    "description": "Optional first name used with individual last-name searches."
                                }
                            }
                        }
                    },
                    "firmNames": {
                        "title": "Firm names",
                        "type": "array",
                        "description": "Optional shortcut list of firm names. These are added to Search queries.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "individualLastNames": {
                        "title": "Individual last names",
                        "type": "array",
                        "description": "Optional shortcut list of individual last names.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "nfaIds": {
                        "title": "NFA IDs",
                        "type": "array",
                        "description": "Optional shortcut list of exact NFA IDs. Numeric IDs are left-padded to 7 digits.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "includeDetails": {
                        "title": "Include profile details",
                        "type": "boolean",
                        "description": "Fetch profile, registration history, activities, and regulatory action summaries for each registrant.",
                        "default": true
                    },
                    "maxItems": {
                        "title": "Maximum registrants",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum registrant rows to save across all searches.",
                        "default": 20
                    },
                    "maxActionsPerRegistrant": {
                        "title": "Max regulatory actions per registrant",
                        "minimum": 0,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Limits the number of detailed regulatory action summaries attached to each output row.",
                        "default": 5
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
