# SEC Form 4 Insider Trades Scraper (`fetch_cat/sec-form-4-insider-trades-scraper`) Actor

Extract transaction-level insider trades from public SEC Form 4 filings by ticker or CIK.

- **URL**: https://apify.com/fetch\_cat/sec-form-4-insider-trades-scraper.md
- **Developed by:** [Hanna Nosova](https://apify.com/fetch_cat) (community)
- **Categories:** News, Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.30 / 1,000 insider trade rows

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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## SEC Form 4 Insider Trades Scraper

Extract transaction-level insider trades from public SEC EDGAR ownership filings by ticker or CIK. The Actor saves one row per reported transaction with issuer details, reporting owner roles, shares, prices, values, ownership fields, and SEC source URLs.

### At a glance

- **Primary job**: Monitor public-company insider transactions from official SEC filings.
- **Input**: Tickers and/or CIKs, filing date bounds, form types, and per-issuer filing limits.
- **Output**: Insider owner, role flags, transaction code/date, shares, price, value, ownership, and SEC source URLs.
- **Best for**: Investor research, compliance exports, BI dashboards, news monitoring, and scheduled watchlists.

### Who is this for?

- **Investors and analysts** tracking insider purchases, sales, grants, and ownership changes.
- **Compliance teams** exporting auditable public Form 4 transaction records by issuer or CIK.
- **Financial journalists** monitoring recent insider activity around public companies.
- **Data teams** feeding SEC insider transactions into dashboards, alerts, or warehouses.

### Input recipes

- **Single ticker smoke test**: `{"tickers":["AAPL"],"formTypes":["4"],"maxFilings":10}`
- **Watchlist**: `{"tickers":["AAPL","MSFT"],"formTypes":["4","4/A"],"maxFilings":10}`
- **Compliance export by CIK**: `{"ciks":["0000320193","789019"],"formTypes":["3","4","4/A","5"],"maxFilings":25,"includeFootnotes":true}`

### What data can you extract?

| Field | Description |
| --- | --- |
| `ticker`, `cik`, `issuerName` | Public company identifiers resolved from SEC data. |
| `accessionNumber`, `formType`, `filedAt`, `periodOfReport` | Filing metadata. |
| `filingUrl`, `xmlUrl` | Audit links back to SEC EDGAR source documents. |
| `reportingOwnerName`, `reportingOwnerCik` | Insider/reporting owner identity. |
| `isDirector`, `isOfficer`, `isTenPercentOwner`, `officerTitle` | Deterministic relationship flags from the filing. |
| `transactionDate`, `transactionCode`, `transactionAcquiredDisposedCode` | Transaction timing and SEC transaction codes. |
| `securityTitle`, `shares`, `pricePerShare`, `transactionValue` | Transaction economics when reported. Gifts/grants may have null price/value. |
| `sharesOwnedFollowingTransaction`, `ownershipNature`, `isDerivative` | Post-transaction and derivative/non-derivative ownership details. |
| `footnotes` | Optional filing footnotes when enabled. |
| `source`, `scrapedAt` | Provenance and scrape timestamp. |

The Actor also writes `RUN_SUMMARY` to the default key-value store with processed issuer counts, matched filing counts, saved transactions, warnings, and per-input failures.

### Input configuration

| Setting | JSON key | Use it for | Example |
| --- | --- | --- | --- |
| Tickers | `tickers` | Resolve public company ticker symbols. | `["AAPL", "MSFT"]` |
| CIKs | `ciks` | Query known SEC CIKs directly; padded and unpadded values work. | `["0000320193", "789019"]` |
| Start/end date | `startDate`, `endDate` | Bound by SEC filing date. | `"2026-01-01"` |
| Form types | `formTypes` | Include Forms 3, 4, 4/A, or 5. | `["4", "4/A"]` |
| Maximum filings | `maxFilings` | Cap filings inspected per issuer. | `10` |
| Derivatives | `includeDerivativeTransactions` | Include derivative transaction table rows. | `false` |
| Footnotes | `includeFootnotes` | Attach SEC filing footnotes to output rows. | `true` |
| Proxy | `proxyConfiguration` | Optional Apify proxy settings; normally leave disabled. | `{ "useApifyProxy": false }` |

### Example input

```json
{
  "tickers": ["AAPL", "MSFT"],
  "formTypes": ["4"],
  "maxFilings": 10,
  "includeDerivativeTransactions": false,
  "includeFootnotes": false,
  "proxyConfiguration": { "useApifyProxy": false }
}
````

### Example output

```json
{
  "ticker": "AAPL",
  "cik": "0000320193",
  "issuerName": "Apple Inc.",
  "accessionNumber": "0000320193-26-000001",
  "formType": "4",
  "filedAt": "2026-01-15",
  "periodOfReport": "2026-01-13",
  "filingUrl": "https://www.sec.gov/Archives/edgar/data/320193/...-index.htm",
  "xmlUrl": "https://www.sec.gov/Archives/edgar/data/320193/.../form4.xml",
  "reportingOwnerName": "Example Owner",
  "reportingOwnerCik": "0000000000",
  "isDirector": true,
  "isOfficer": false,
  "isTenPercentOwner": false,
  "officerTitle": null,
  "transactionDate": "2026-01-13",
  "transactionCode": "P",
  "transactionAcquiredDisposedCode": "A",
  "securityTitle": "Common Stock",
  "shares": 1000,
  "pricePerShare": 150.25,
  "transactionValue": 150250,
  "sharesOwnedFollowingTransaction": 5000,
  "ownershipNature": "D",
  "isDerivative": false,
  "footnotes": null,
  "source": "SEC_EDGAR",
  "scrapedAt": "2026-07-21T00:00:00.000Z"
}
```

### Pricing

| Event | Price | Charged when |
| --- | --- | --- |
| Run start | `$0.005` per run | Once when the Actor starts. |
| Transaction row saved | Free `$0.000575`, Bronze `$0.0005`, Silver `$0.00039`, Gold `$0.0003`, Platinum `$0.0002`, Diamond `$0.00014` per row | Each parsed transaction row saved to the dataset. |

### API usage

#### cURL

```bash
curl "https://api.apify.com/v2/acts/fetch_cat~sec-form-4-insider-trades-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"tickers":["AAPL"],"formTypes":["4"],"maxFilings":10}'
```

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('fetch_cat/sec-form-4-insider-trades-scraper').call({
  tickers: ['AAPL'],
  formTypes: ['4'],
  maxFilings: 10,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('MY-APIFY-TOKEN')
run = client.actor('fetch_cat/sec-form-4-insider-trades-scraper').call(run_input={
    'tickers': ['AAPL'],
    'formTypes': ['4'],
    'maxFilings': 10,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### MCP and AI agents

Use this Actor from Apify MCP Server when an agent needs structured SEC insider-trade rows. Configure the MCP endpoint with:

```text
https://mcp.apify.com/?tools=fetch_cat/sec-form-4-insider-trades-scraper
```

Add it to Claude CLI with:

```bash
claude mcp add apify-sec-form-4 'https://mcp.apify.com/?tools=fetch_cat/sec-form-4-insider-trades-scraper'
```

JSON config example:

```json
{
  "mcpServers": {
    "apify-sec-form-4": {
      "url": "https://mcp.apify.com/?tools=fetch_cat/sec-form-4-insider-trades-scraper"
    }
  }
}
```

Example prompts:

- "Get recent Form 4 insider transactions for AAPL, maximum 10 filings."
- "Export Form 4 and 4/A rows for CIK 0000320193 with footnotes."
- "Check AAPL and MSFT insider trades and summarize the transaction codes."

Good agent prompts include the ticker/CIK list, date range, whether derivatives are needed, and the maximum filings per issuer.

### Tips for best results

- **Use focused watchlists**: Split very large universes into smaller scheduled runs.
- **Keep `maxFilings` bounded**: Start with 10-25 filings per issuer, then increase if needed.
- **Use CIKs for compliance workflows**: CIK inputs avoid ticker ambiguity and survive ticker changes.
- **Expect nullable economics**: Gifts, grants, and some derivative rows may not report a cash price.

### Limits and responsible use

This Actor only extracts official public SEC EDGAR ownership filings. It does not provide investment advice, buy/sell recommendations, AI scoring, private brokerage data, or Congress disclosure data. Use the data for research, compliance, and reporting, and verify important decisions against the linked SEC filing.

### Related Actors

- [SEC EDGAR Company Filings Scraper](https://apify.com/fetch_cat/sec-edgar-company-filings-scraper) for broader company filing discovery.
- [SEC Form 4 Insider Trades Scraper](https://apify.com/fetch_cat/sec-form-4-insider-trades-scraper) for transaction-level ownership filings once published.

### FAQ

**Does this Actor give investment advice?**\
No. It returns structured public filing data only.

**Can I input CIKs instead of tickers?**\
Yes. Use `ciks` with padded or unpadded SEC CIK values.

**Why are price or value fields sometimes null?**\
Some transaction codes, grants, gifts, or derivative records do not report a cash price.

**Where do diagnostics live?**\
The default key-value store contains `RUN_SUMMARY` with status, warning, and failure details.

### Support

If a run does not return what you expected, open an Apify issue and include:

- the run ID or run URL;
- the exact input JSON;
- the expected output;
- the actual output or empty dataset detail;
- a reproducible public URL such as an SEC filing URL, plus the ticker or CIK used.

# Actor input Schema

## `tickers` (type: `array`):

Public company ticker symbols to resolve through SEC company\_tickers.json.

## `ciks` (type: `array`):

SEC Central Index Keys. Values may be padded or unpadded.

## `startDate` (type: `string`):

Optional filing date lower bound in YYYY-MM-DD format.

## `endDate` (type: `string`):

Optional filing date upper bound in YYYY-MM-DD format.

## `formTypes` (type: `array`):

SEC ownership forms to include.

## `maxFilings` (type: `integer`):

Maximum matching SEC filings to inspect for each resolved ticker or CIK.

## `includeDerivativeTransactions` (type: `boolean`):

Also parse derivative transaction tables when present.

## `includeFootnotes` (type: `boolean`):

Attach filing footnotes to each output row. Footnotes may make rows larger.

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

Optional proxy settings. Disabled by default because SEC EDGAR public endpoints normally work without a proxy when a descriptive User-Agent is used.

## Actor input object example

```json
{
  "tickers": [
    "AAPL"
  ],
  "formTypes": [
    "4"
  ],
  "maxFilings": 10,
  "includeDerivativeTransactions": false,
  "includeFootnotes": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# 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 = {
    "tickers": [
        "AAPL"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/sec-form-4-insider-trades-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 = { "tickers": ["AAPL"] }

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/sec-form-4-insider-trades-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 '{
  "tickers": [
    "AAPL"
  ]
}' |
apify call fetch_cat/sec-form-4-insider-trades-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=fetch_cat/sec-form-4-insider-trades-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "SEC Form 4 Insider Trades Scraper",
        "description": "Extract transaction-level insider trades from public SEC Form 4 filings by ticker or CIK.",
        "version": "0.1",
        "x-build-id": "rWRlJ2fWIeXk4WnN0"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fetch_cat~sec-form-4-insider-trades-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fetch_cat-sec-form-4-insider-trades-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/fetch_cat~sec-form-4-insider-trades-scraper/runs": {
            "post": {
                "operationId": "runs-sync-fetch_cat-sec-form-4-insider-trades-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/fetch_cat~sec-form-4-insider-trades-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-fetch_cat-sec-form-4-insider-trades-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": {
                    "tickers": {
                        "title": "Tickers",
                        "type": "array",
                        "description": "Public company ticker symbols to resolve through SEC company_tickers.json.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "ciks": {
                        "title": "CIKs",
                        "type": "array",
                        "description": "SEC Central Index Keys. Values may be padded or unpadded.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startDate": {
                        "title": "Start date",
                        "type": "string",
                        "description": "Optional filing date lower bound in YYYY-MM-DD format."
                    },
                    "endDate": {
                        "title": "End date",
                        "type": "string",
                        "description": "Optional filing date upper bound in YYYY-MM-DD format."
                    },
                    "formTypes": {
                        "title": "Form types",
                        "type": "array",
                        "description": "SEC ownership forms to include.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "3",
                                "4",
                                "4/A",
                                "5"
                            ],
                            "enumTitles": [
                                "Form 3",
                                "Form 4",
                                "Form 4/A amendment",
                                "Form 5"
                            ]
                        },
                        "default": [
                            "4"
                        ]
                    },
                    "maxFilings": {
                        "title": "Maximum filings per issuer",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Maximum matching SEC filings to inspect for each resolved ticker or CIK.",
                        "default": 10
                    },
                    "includeDerivativeTransactions": {
                        "title": "Include derivative transactions",
                        "type": "boolean",
                        "description": "Also parse derivative transaction tables when present.",
                        "default": false
                    },
                    "includeFootnotes": {
                        "title": "Include footnotes",
                        "type": "boolean",
                        "description": "Attach filing footnotes to each output row. Footnotes may make rows larger.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional proxy settings. Disabled by default because SEC EDGAR public endpoints normally work without a proxy when a descriptive User-Agent is used.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
