# FINRA Disciplinary Actions Scraper (`automation-lab/finra-disciplinary-actions-scraper`) Actor

Extract FINRA disciplinary actions, sanctions, bars, fines, respondents, dates, summaries, and source document URLs for compliance monitoring.

- **URL**: https://apify.com/automation-lab/finra-disciplinary-actions-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Business
- **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

## FINRA Disciplinary Actions Scraper

Extract public FINRA disciplinary actions, sanctions, bars, fines, suspensions, respondent names, official dates, summaries, and source document URLs from FINRA's disciplinary actions database.

Use this actor when you need structured compliance monitoring data from FINRA without manually searching the website page by page.

### What does FINRA Disciplinary Actions Scraper do?

FINRA Disciplinary Actions Scraper turns FINRA's public disciplinary action listings into clean dataset records.

It can collect:

- Case IDs
- Respondent names
- Firm names
- Individual names
- Document/action types
- Official dates
- Action summaries
- Sanction indicators
- Fine amounts mentioned in summaries
- Restitution amounts mentioned in summaries
- Bars, suspensions, and censures
- PDF/source document URLs
- Related-document search URLs

### Who is it for?

FINRA Disciplinary Actions Scraper is designed for compliance and regulatory-data workflows.

Common users include:

- Broker-dealer compliance teams monitoring disciplinary trends
- Legal research teams reviewing enforcement history
- Due-diligence vendors screening firms and individuals
- Recruiting/background-check workflows checking FINRA sanctions
- AML/KYC data teams enriching watchlist and adverse-action databases
- Regulatory intelligence platforms that need repeatable FINRA monitoring

### Why use this actor?

FINRA's website is searchable, but manual monitoring is slow.

This actor helps you:

- Export FINRA disciplinary action records to JSON, CSV, Excel, XML, or HTML
- Monitor new actions on a schedule
- Filter by keyword, firm, individual, case ID, document type, and date range
- Capture source evidence links for audit trails
- Normalize sanctions into fields that are easier to filter downstream
- Feed compliance systems without copy-paste work

### Data source

The actor extracts data from the public FINRA disciplinary actions listing:

`https://www.finra.org/rules-guidance/oversight-enforcement/finra-disciplinary-actions`

The source is public and does not require a FINRA account.

### Output data

Each dataset item represents one FINRA disciplinary action row.

| Field | Description |
| --- | --- |
| `caseId` | FINRA case/document identifier |
| `title` | Combined case/respondent/document title |
| `summary` | FINRA summary text |
| `documentType` | FINRA document type |
| `officialDate` | Official date shown by FINRA |
| `respondents` | Respondent names |
| `firms` | Firm respondents when identified |
| `individuals` | Individual respondents when identified |
| `sanctions` | Inferred sanction categories |
| `fineAmounts` | Fine amounts mentioned in the summary |
| `restitutionAmounts` | Restitution amounts mentioned in the summary |
| `hasBar` | Whether the summary mentions a bar |
| `hasSuspension` | Whether the summary mentions a suspension |
| `hasCensure` | Whether the summary mentions censure |
| `documentUrl` | FINRA PDF/document URL |
| `relatedDocumentsUrl` | FINRA related-documents URL when present |
| `sourceUrl` | FINRA results page used for extraction |
| `scrapedAt` | Extraction timestamp |

### Example output

```json
{
  "caseId": "2026090120801",
  "title": "2026090120801 — Sung Moo Cho — AWCs (Letters of Acceptance, Waiver, and Consent)",
  "documentType": "AWCs (Letters of Acceptance, Waiver, and Consent)",
  "officialDate": "06/25/2026",
  "respondents": ["Sung Moo Cho"],
  "individuals": ["Sung Moo Cho"],
  "sanctions": ["bar"],
  "hasBar": true,
  "documentUrl": "https://www.finra.org/sites/default/files/fda_documents/...pdf"
}
````

### How much does it cost to scrape FINRA disciplinary actions?

This actor uses pay-per-event pricing.

You pay a small start fee for the run and a per-record charge for each disciplinary action saved to the dataset.

Use a low `maxItems` value for quick tests and increase it for scheduled monitoring or historical backfills.

### Input options

You can search FINRA records with the following inputs:

- `search` — case ID, document text, name, or CRD number
- `firmName` — firm name or firm CRD
- `individualName` — individual name or CRD
- `caseId` — FINRA case number
- `documentType` — AWC, Complaint, OHO Decision, NAC Decision, SEC Decision, and more
- `dateFrom` — earliest official date
- `dateTo` — latest official date
- `maxItems` — maximum records to save
- `startPage` — advanced pagination offset
- `proxyConfiguration` — Apify Proxy settings

### How to scrape FINRA disciplinary actions

1. Open the actor on Apify.
2. Enter a keyword, firm name, individual name, case ID, or date range.
3. Choose a document type if needed.
4. Set `maxItems`.
5. Run the actor.
6. Export the dataset in your preferred format.

### Search examples

Try these workflows:

- Search `barred` to monitor barred individuals and firms.
- Filter by firm name to review actions involving one broker-dealer.
- Filter by individual name or CRD for background checks.
- Filter AWCs from a recent date range for compliance monitoring.
- Search a FINRA case number to collect related documents.

### Integrations

You can connect the output to:

- Google Sheets compliance dashboards
- Airtable legal research trackers
- BigQuery or Snowflake regulatory datasets
- CRM/vendor due-diligence workflows
- Background-check pipelines
- Slack or email alerts through Apify integrations
- BI dashboards that track sanctions and fines over time

### 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/finra-disciplinary-actions-scraper').call({
  search: 'barred',
  maxItems: 100,
});
console.log(run.defaultDatasetId);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/finra-disciplinary-actions-scraper').call({
    'search': 'barred',
    'maxItems': 100,
})
print(run['defaultDatasetId'])
```

#### cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~finra-disciplinary-actions-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"search":"barred","maxItems":100}'
```

### MCP integration

Use this actor through Apify MCP in Claude Desktop or Claude Code.

MCP URL:

`https://mcp.apify.com/?tools=automation-lab/finra-disciplinary-actions-scraper`

Claude Code CLI setup:

```bash
claude mcp add apify-finra-disciplinary-actions https://mcp.apify.com/?tools=automation-lab/finra-disciplinary-actions-scraper
```

Claude Desktop JSON config:

```json
{
  "mcpServers": {
    "apify-finra-disciplinary-actions": {
      "url": "https://mcp.apify.com/?tools=automation-lab/finra-disciplinary-actions-scraper"
    }
  }
}
```

Example prompts:

- "Scrape FINRA disciplinary actions mentioning barred representatives and summarize the top sanctions."
- "Find recent FINRA AWCs involving restitution and export the document URLs."
- "Monitor FINRA disciplinary actions for this firm name and return new records."

### Tips for better results

- Use `maxItems` to control cost and run duration.
- Combine `dateFrom` and `dateTo` for recurring monitoring windows.
- Use firm or individual filters when you know the respondent.
- Use keyword search for sanctions such as `barred`, `fined`, `restitution`, or `suspended`.
- Keep source document URLs with your downstream records for auditability.

### Limitations

Sanction fields are inferred from FINRA summary text.

They are useful for filtering and triage but should not replace legal review of the source document.

FINRA may update page structure or documents; source URLs are included so you can verify records.

### Legality

The actor extracts publicly available regulatory records from FINRA.

You are responsible for using the data lawfully, respecting applicable terms, privacy rules, and compliance obligations.

Do not use the output as the sole basis for employment, credit, or legal decisions without appropriate review.

### Troubleshooting

If you get fewer results than expected:

- Broaden filters.
- Increase `maxItems`.
- Remove exact case or respondent filters.
- Check whether FINRA has records for that period.

If FINRA returns temporary blocking or cooldown responses:

- Use the prefilled Apify Proxy configuration.
- Retry later for very large backfills.
- Split historical pulls into smaller date windows.

### Related scrapers

Explore more Automation Lab actors for compliance and due-diligence workflows:

- https://apify.com/automation-lab/opensanctions-entities-scraper
- https://apify.com/automation-lab/company-information-scraper
- https://apify.com/automation-lab/website-contact-finder

### FAQ

#### Can I scrape only one FINRA case?

Yes. Use the `caseId` input or put the case number into `search`.

#### Can I monitor new disciplinary actions?

Yes. Schedule the actor and use a recent `dateFrom`/`dateTo` window.

#### Does the actor download PDFs?

The actor saves FINRA document URLs. It does not currently download or parse PDF contents.

#### Does it require login?

No. The actor uses FINRA's public disciplinary actions listing.

#### Can I filter bars and fines?

Use keyword search such as `barred`, `fine`, `fined`, `restitution`, or `suspended`. The output also includes inferred sanction fields.

# Actor input Schema

## `search` (type: `string`):

Search Case ID, document text, respondent name, or CRD number.

## `firmName` (type: `string`):

Optional firm respondent filter, matching FINRA's Firm Name or CRD field.

## `individualName` (type: `string`):

Optional individual respondent filter, matching FINRA's Individual Name or CRD field.

## `caseId` (type: `string`):

Optional exact or partial FINRA disciplinary action case number.

## `documentType` (type: `string`):

FINRA disciplinary action document type filter.

## `dateFrom` (type: `string`):

Earliest official date in YYYY-MM-DD format.

## `dateTo` (type: `string`):

Latest official date in YYYY-MM-DD format.

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

Maximum number of disciplinary action records to save.

## `startPage` (type: `integer`):

Advanced: zero-based FINRA results page to start from.

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

Use Apify Proxy to avoid FINRA cooldowns on repeated monitoring runs. SHADER/datacenter proxy is prefilled for low cost.

## Actor input object example

```json
{
  "search": "barred",
  "documentType": "All",
  "maxItems": 20,
  "startPage": 0,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "SHADER"
    ]
  }
}
```

# 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 = {
    "search": "barred",
    "documentType": "All",
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "SHADER"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/finra-disciplinary-actions-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 = {
    "search": "barred",
    "documentType": "All",
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["SHADER"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/finra-disciplinary-actions-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 '{
  "search": "barred",
  "documentType": "All",
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "SHADER"
    ]
  }
}' |
apify call automation-lab/finra-disciplinary-actions-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "FINRA Disciplinary Actions Scraper",
        "description": "Extract FINRA disciplinary actions, sanctions, bars, fines, respondents, dates, summaries, and source document URLs for compliance monitoring.",
        "version": "0.1",
        "x-build-id": "f24WmCCU7eNvSX0dm"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~finra-disciplinary-actions-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-finra-disciplinary-actions-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~finra-disciplinary-actions-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-finra-disciplinary-actions-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~finra-disciplinary-actions-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-finra-disciplinary-actions-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",
                "properties": {
                    "search": {
                        "title": "Keyword / case / CRD search",
                        "type": "string",
                        "description": "Search Case ID, document text, respondent name, or CRD number."
                    },
                    "firmName": {
                        "title": "Firm name or CRD",
                        "type": "string",
                        "description": "Optional firm respondent filter, matching FINRA's Firm Name or CRD field."
                    },
                    "individualName": {
                        "title": "Individual name or CRD",
                        "type": "string",
                        "description": "Optional individual respondent filter, matching FINRA's Individual Name or CRD field."
                    },
                    "caseId": {
                        "title": "Case number",
                        "type": "string",
                        "description": "Optional exact or partial FINRA disciplinary action case number."
                    },
                    "documentType": {
                        "title": "Document type",
                        "enum": [
                            "All",
                            "4610",
                            "4611",
                            "4612",
                            "4613",
                            "4614",
                            "4615",
                            "4616",
                            "4617"
                        ],
                        "type": "string",
                        "description": "FINRA disciplinary action document type filter.",
                        "default": "All"
                    },
                    "dateFrom": {
                        "title": "Official date from",
                        "type": "string",
                        "description": "Earliest official date in YYYY-MM-DD format."
                    },
                    "dateTo": {
                        "title": "Official date to",
                        "type": "string",
                        "description": "Latest official date in YYYY-MM-DD format."
                    },
                    "maxItems": {
                        "title": "Maximum disciplinary actions",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of disciplinary action records to save.",
                        "default": 20
                    },
                    "startPage": {
                        "title": "Start page",
                        "minimum": 0,
                        "maximum": 1293,
                        "type": "integer",
                        "description": "Advanced: zero-based FINRA results page to start from.",
                        "default": 0
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Use Apify Proxy to avoid FINRA cooldowns on repeated monitoring runs. SHADER/datacenter proxy is prefilled for low cost."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```