# NFA BASIC Futures Registration & Disciplinary Scraper (`crawlerbros/nfa-basic-futures-registration-scraper`) Actor

Search NFA BASIC - the free, CFTC-mandated registry of futures industry firms, associated persons, and commodity pools. Look up by name or NFA ID for membership status, registered categories, addresses, and disciplinary action history. No login required.

- **URL**: https://apify.com/crawlerbros/nfa-basic-futures-registration-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Automation, Developer tools, Other
- **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 and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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 Futures Registration & Disciplinary Scraper

Scrape the National Futures Association's **BASIC** (Background Affiliation Status Information Center) database — the free, CFTC-mandated public registry of every futures industry firm (Futures Commission Merchants, Introducing Brokers, Commodity Pool Operators, Commodity Trading Advisors, Swap Dealers), associated person, and commodity pool in the United States. Search by name, or pull a full profile by NFA ID: membership status, registered categories, office address, and disciplinary/regulatory action history. No login, no API key, no proxy.

### Data source note

This actor replaces an originally planned NMLS Consumer Access scraper. Investigation confirmed nmlsconsumeraccess.org has no JSON API, and its search/detail pages are gated behind a real interactive CAPTCHA (`TuringTestPage.aspx`, a commercial BotDetect component) that triggers even for a full real-browser session with organic cookies and history — confirmed via direct browser automation, not just a naive HTTP client. NFA BASIC is a same-category (financial/professional licensing + disciplinary disclosure registry, CFTC/SAFE-Act-equivalent mandate) zero-cost replacement backed by a genuine, reliable public JSON API.

### What this actor does

- **Four modes:** `searchFirms`, `searchIndividuals`, `searchPools`, `entityProfile`
- **Firms** — Futures Commission Merchants, Introducing Brokers, CPOs, CTAs, Swap Dealers, and more
- **Individuals** — Associated Persons (APs) searchable by last name
- **Commodity pools** — searchable by pool name, linked to their operator (CPO)
- **Full profile lookup** by NFA ID or Pool ID — address, DBAs, registration history and full registration timeline, principals/owners, pools operated (for CPOs), CFTC exemption filings, and structured disciplinary/regulatory actions (reference number, effective date, outcome, action type)
- **Filters:** membership status, regulatory-actions-only, firm registration category, individual registration category, pool status, firm state
- **Empty fields are omitted**

### Output per record

**Search results** (`searchFirms` / `searchIndividuals` / `searchPools`):
- `nfaId`, `entityType` (`firm` / `individual` / `pool`), `name`
- `firstName`, `lastName` (individuals), `sponsorName` (individuals)
- `city`, `state` (firms, when NFA has an address on file)
- `cpoName`, `cpoNfaId`, `cpoMembershipStatus`, `poolStatus` (pools)
- `membershipStatus`, `registrationTypes[]`
- `hasRegulatoryActions`, `regulatoryActionsCount`
- `sourceUrl`, `recordType`, `scrapedAt`

**Full profile** (`entityProfile`) — adds:
- `street1`, `street2`, `city`, `state`, `postalCode`, `country`, `phone`
- `doingBusinessAs[]`
- `registrationHistory[]` (current status per category: category, description, effective date)
- `registrationTimeline[]` (full chronological history of every registered/pending/withdrawn transition: category, description, effective date)
- `currentRegistrations[]` (category, status)
- `principals[]` (firms/pools' filing firm) — `name`, `nfaId`, `title`, `tenPercentOwner`
- `poolsOperated[]`, `poolsCurrentCount`, `poolsCeasedCount` (CPO firms only — pool ID, name, exemption type, withdrawn status)
- `cftcExemptions[]` (firms/pools with a CFTC exemption filing, e.g. Rule 4.7/4.13) — `exemptionType`, `status`, `activityDate`
- `isNfaMember`, `isOnWithdrawalHold`
- `arbitrationCasesCount`, `reparationsCasesCount` (dispute-resolution case counts, distinct from disciplinary actions)
- `regulatoryActions[]` — `referenceNumber`, `effectiveDate`, `contributor`, `outcomes[]`, `actions[]`, `barrableOffense`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `searchFirms` | `searchFirms` / `searchIndividuals` / `searchPools` / `entityProfile` |
| `searchQuery` | string | `Merrill` | Firm/pool name (required for `searchFirms`/`searchPools`) |
| `lastName` | string | `Smith` | Individual's last name (required for `searchIndividuals`) |
| `firstName` | string | – | Optional first-name refinement (`searchIndividuals`) |
| `firmCategory` | string | – | Filter firms to one NFA registration category (`searchFirms`), e.g. Futures Commission Merchant, Introducing Broker, CPO, CTA, Swap Dealer |
| `individualCategory` | string | – | Filter individuals to one NFA registration category (`searchIndividuals`), e.g. Associated Person, Principal, Floor Broker |
| `poolStatus` | string | – | Filter pools to `CURRENT` or `CEASED` (`searchPools`) |
| `state` | string | – | Filter firms to a US state/territory of their registered address (`searchFirms`) |
| `nfaIds` | array | – | NFA IDs or Pool IDs to fetch full profiles for (`entityProfile`) |
| `membershipStatus` | string | – | Filter to a specific NFA membership status (search modes only — ignored for `entityProfile`, which always returns the requested ID) |
| `hasRegulatoryActionsOnly` | boolean | `false` | Only emit firm/individual search records with a disciplinary/regulatory action on file. Not supported for `mode=searchPools` (see Limitations) and ignored for `entityProfile` (always returns the requested ID) |
| `maxItems` | integer | `20` | Hard cap on emitted records (1–1000) |

#### Example: search firms by name

```json
{ "mode": "searchFirms", "searchQuery": "Merrill", "maxItems": 25 }
````

#### Example: introducing brokers in Illinois

```json
{ "mode": "searchFirms", "searchQuery": "a", "firmCategory": "Introducing Broker", "state": "IL", "maxItems": 25 }
```

#### Example: individuals with regulatory actions

```json
{ "mode": "searchIndividuals", "lastName": "Smith", "hasRegulatoryActionsOnly": true }
```

#### Example: registered principals of a firm

```json
{ "mode": "searchIndividuals", "lastName": "Smith", "individualCategory": "Principal Approved" }
```

#### Example: full profile by NFA ID

```json
{ "mode": "entityProfile", "nfaIds": ["0392970", "0254922"] }
```

#### Example: search commodity pools

```json
{ "mode": "searchPools", "searchQuery": "Fund", "poolStatus": "CURRENT" }
```

### Limitations

- **No CRD-number search.** NFA BASIC's own search UI indexes firms/individuals only by name, NFA ID/Pool ID, and (for individuals) last name — it does not offer a CRD-number lookup axis, so this actor doesn't either.
- **No employment/exam history.** Unlike FINRA BrokerCheck, NFA BASIC's public registry does not publish an individual's employment history or proficiency-exam history — NFA simply doesn't expose this data publicly.
- **`hasRegulatoryActionsOnly` doesn't apply to `searchPools`.** NFA's own pool-name-search API doesn't return a regulatory-actions column on pool rows at all (firms and individuals do carry one). Combining `mode=searchPools` with `hasRegulatoryActionsOnly=true` returns 0 records immediately with an explanatory status message rather than silently paginating the whole result set. Use `mode=entityProfile` with the pool's ID to check for regulatory actions on a specific pool.

### Use cases

- **Due diligence** — verify a futures broker, advisor, or pool operator's registration and disciplinary history
- **Compliance monitoring** — track membership-status changes for a watchlist of firms/individuals
- **Fintech vetting** — confirm NFA membership before onboarding a futures-industry counterparty
- **Journalism & research** — bulk-analyze regulatory actions across the futures industry
- **Fund due diligence** — trace a commodity pool back to its registered operator

### FAQ

**What's NFA BASIC?** The National Futures Association's public registry of every firm and individual registered with the CFTC to conduct futures/derivatives business — the futures-industry counterpart to FINRA BrokerCheck / SEC IAPD, mandated to be freely and publicly searchable.

**What's an NFA ID?** A unique 7-digit identifier assigned to every registered firm and individual. Commodity pools use a `P`-prefixed Pool ID instead (e.g. `P207559`).

**Why do full profiles have more fields than search results?** The search endpoint returns a lightweight summary row; `entityProfile` calls the full BASIC profile API, which includes address, registration history, and structured disciplinary/regulatory action records. Use search to discover NFA IDs, then look up the ID for the full picture.

**Can I look up a commodity pool's full profile too?** Yes — pass its Pool ID (e.g. `P207559`) to `entityProfile`; the actor auto-detects the entity type.

**Is this data official?** Yes — sourced live from the NFA's own `nfa.futures.org/BasicNet` JSON backend, the same data that powers the public BASIC search tool.

**How fresh is the data?** Real-time — every request hits the live NFA API.

# Actor input Schema

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

What to fetch.

## `searchQuery` (type: `string`):

Firm or pool name (mode=searchFirms/searchPools, required).

## `lastName` (type: `string`):

Individual's last name — required for mode=searchIndividuals.

## `firstName` (type: `string`):

Optional first-name refinement for mode=searchIndividuals.

## `firmCategory` (type: `string`):

Only return firms currently holding this NFA registration category. Applied server-side by NFA BASIC's own search API.

## `individualCategory` (type: `string`):

Only return individuals currently holding this NFA registration category. Applied server-side by NFA BASIC's own search API.

## `poolStatus` (type: `string`):

Only return commodity pools with this current status. Applied server-side by NFA BASIC's own search API.

## `state` (type: `string`):

Only return firms whose registered business address is in this US state/territory. Only applies when NFA has an address on file for the firm.

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

One or more NFA IDs (e.g. `0186926`) or Pool IDs (e.g. `P207559`) to fetch full profiles for.

## `membershipStatus` (type: `string`):

Only emit records matching this NFA membership status (search modes only).

## `hasRegulatoryActionsOnly` (type: `boolean`):

When on, only emit firms/individuals flagged as having a disciplinary or regulatory action on file. Not supported for mode=searchPools — NFA's own pool-search results don't carry a regulatory-actions flag on pool rows; use mode=entityProfile with the pool's ID instead, which does report it. Does not apply to mode=entityProfile (a byId lookup always returns the requested ID's profile).

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

Hard cap on emitted records.

## Actor input object example

```json
{
  "mode": "searchFirms",
  "searchQuery": "Merrill",
  "lastName": "Smith",
  "firmCategory": "",
  "individualCategory": "",
  "poolStatus": "",
  "state": "",
  "nfaIds": [],
  "membershipStatus": "",
  "hasRegulatoryActionsOnly": false,
  "maxItems": 20
}
```

# Actor output Schema

## `entities` (type: `string`):

Dataset containing all scraped NFA firm/individual/pool records.

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "mode": "searchFirms",
    "searchQuery": "Merrill",
    "lastName": "Smith",
    "firmCategory": "",
    "individualCategory": "",
    "poolStatus": "",
    "state": "",
    "nfaIds": [],
    "membershipStatus": "",
    "hasRegulatoryActionsOnly": false,
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/nfa-basic-futures-registration-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 = {
    "mode": "searchFirms",
    "searchQuery": "Merrill",
    "lastName": "Smith",
    "firmCategory": "",
    "individualCategory": "",
    "poolStatus": "",
    "state": "",
    "nfaIds": [],
    "membershipStatus": "",
    "hasRegulatoryActionsOnly": False,
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/nfa-basic-futures-registration-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 '{
  "mode": "searchFirms",
  "searchQuery": "Merrill",
  "lastName": "Smith",
  "firmCategory": "",
  "individualCategory": "",
  "poolStatus": "",
  "state": "",
  "nfaIds": [],
  "membershipStatus": "",
  "hasRegulatoryActionsOnly": false,
  "maxItems": 20
}' |
apify call crawlerbros/nfa-basic-futures-registration-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "NFA BASIC Futures Registration & Disciplinary Scraper",
        "description": "Search NFA BASIC - the free, CFTC-mandated registry of futures industry firms, associated persons, and commodity pools. Look up by name or NFA ID for membership status, registered categories, addresses, and disciplinary action history. No login required.",
        "version": "1.0",
        "x-build-id": "awHEPSfsEQPJRHelB"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~nfa-basic-futures-registration-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-nfa-basic-futures-registration-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/crawlerbros~nfa-basic-futures-registration-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-nfa-basic-futures-registration-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/crawlerbros~nfa-basic-futures-registration-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-nfa-basic-futures-registration-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": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "searchFirms",
                            "searchIndividuals",
                            "searchPools",
                            "entityProfile"
                        ],
                        "type": "string",
                        "description": "What to fetch.",
                        "default": "searchFirms"
                    },
                    "searchQuery": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Firm or pool name (mode=searchFirms/searchPools, required).",
                        "default": "Merrill"
                    },
                    "lastName": {
                        "title": "Last name (mode=searchIndividuals)",
                        "type": "string",
                        "description": "Individual's last name — required for mode=searchIndividuals.",
                        "default": "Smith"
                    },
                    "firstName": {
                        "title": "First name (mode=searchIndividuals)",
                        "type": "string",
                        "description": "Optional first-name refinement for mode=searchIndividuals."
                    },
                    "firmCategory": {
                        "title": "Firm registration category (mode=searchFirms)",
                        "enum": [
                            "",
                            "Futures Commission Merchant",
                            "Introducing Broker",
                            "Notice Introducing Broker",
                            "Commodity Pool Operator",
                            "Exempt Commodity Pool Operator",
                            "Commodity Trading Advisor",
                            "Exempt Commodity Trading Advisor",
                            "Retail Foreign Exchange Dealer",
                            "Swap Dealer",
                            "Exempt Foreign Firm",
                            "Exempt Foreign Firm Regulator",
                            "Commodity Exchange"
                        ],
                        "type": "string",
                        "description": "Only return firms currently holding this NFA registration category. Applied server-side by NFA BASIC's own search API.",
                        "default": ""
                    },
                    "individualCategory": {
                        "title": "Individual registration category (mode=searchIndividuals)",
                        "enum": [
                            "",
                            "Associated Person Registered",
                            "Principal Approved",
                            "Branch Manager Approved",
                            "Floor Broker Registered",
                            "Floor Trader Registered",
                            "Commodity Trading Advisor Registered",
                            "NFA Associate Member Approved"
                        ],
                        "type": "string",
                        "description": "Only return individuals currently holding this NFA registration category. Applied server-side by NFA BASIC's own search API.",
                        "default": ""
                    },
                    "poolStatus": {
                        "title": "Pool status (mode=searchPools)",
                        "enum": [
                            "",
                            "CURRENT",
                            "CEASED"
                        ],
                        "type": "string",
                        "description": "Only return commodity pools with this current status. Applied server-side by NFA BASIC's own search API.",
                        "default": ""
                    },
                    "state": {
                        "title": "Firm state (mode=searchFirms)",
                        "enum": [
                            "",
                            "AL",
                            "AK",
                            "AZ",
                            "AR",
                            "CA",
                            "CO",
                            "CT",
                            "DE",
                            "FL",
                            "GA",
                            "HI",
                            "ID",
                            "IL",
                            "IN",
                            "IA",
                            "KS",
                            "KY",
                            "LA",
                            "ME",
                            "MD",
                            "MA",
                            "MI",
                            "MN",
                            "MS",
                            "MO",
                            "MT",
                            "NE",
                            "NV",
                            "NH",
                            "NJ",
                            "NM",
                            "NY",
                            "NC",
                            "ND",
                            "OH",
                            "OK",
                            "OR",
                            "PA",
                            "RI",
                            "SC",
                            "SD",
                            "TN",
                            "TX",
                            "UT",
                            "VT",
                            "VA",
                            "WA",
                            "WV",
                            "WI",
                            "WY",
                            "DC",
                            "PR",
                            "VI",
                            "GU",
                            "AS",
                            "MP"
                        ],
                        "type": "string",
                        "description": "Only return firms whose registered business address is in this US state/territory. Only applies when NFA has an address on file for the firm.",
                        "default": ""
                    },
                    "nfaIds": {
                        "title": "NFA IDs / Pool IDs (mode=entityProfile)",
                        "type": "array",
                        "description": "One or more NFA IDs (e.g. `0186926`) or Pool IDs (e.g. `P207559`) to fetch full profiles for.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "membershipStatus": {
                        "title": "Membership status filter",
                        "enum": [
                            "",
                            "NFA Member Approved",
                            "Not an NFA Member",
                            "Pending NFA Member",
                            "Permanent Bar",
                            "Permanent Withdrawal",
                            "Temporary Withdrawal",
                            "Shall Not Reapply for NFA Membership Status",
                            "Shall Not Be Listed Or Act as a Principal of an NFA Member",
                            "Temporary - Shall Not Be Listed or Act as a Principal of an NFA Member"
                        ],
                        "type": "string",
                        "description": "Only emit records matching this NFA membership status (search modes only).",
                        "default": ""
                    },
                    "hasRegulatoryActionsOnly": {
                        "title": "Only records with regulatory actions on file",
                        "type": "boolean",
                        "description": "When on, only emit firms/individuals flagged as having a disciplinary or regulatory action on file. Not supported for mode=searchPools — NFA's own pool-search results don't carry a regulatory-actions flag on pool rows; use mode=entityProfile with the pool's ID instead, which does report it. Does not apply to mode=entityProfile (a byId lookup always returns the requested ID's profile).",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Hard cap on emitted records.",
                        "default": 20
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
