# Stock Insider Trading - SEC Form 4 Buys, Sells & Cluster Buys (`michael_b/stock-insider-trading`) Actor

Track insider trading from SEC Form 4 filings: insider buys and sells market-wide or per ticker. Filter by trade value, insider role (CEO, CFO, director), and date. Detect cluster buys where multiple insiders buy the same stock. Clean flat JSON for AI agents, LLM pipelines, and trading signals.

- **URL**: https://apify.com/michael\_b/stock-insider-trading.md
- **Developed by:** [Michal Búci](https://apify.com/michael_b) (community)
- **Categories:** MCP servers, Agents, Developer tools
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## Stock Insider Trading - SEC Form 4 Buys, Sells & Cluster Buys

Track what corporate insiders do with their own money. This actor returns insider trading transactions from SEC Form 4 filings as clean, flat JSON — across the **entire US stock market** or for **specific tickers**, with built-in **cluster buy detection** (multiple insiders buying the same stock).

Built for AI agents, LLM pipelines, trading signal research, and market monitoring. Every field is typed, documented, and compact — one flat row per transaction that drops straight into a spreadsheet, database, or LLM context window. Data comes straight from SEC Form 4 filings, updated continuously throughout the trading day.

### What makes it different

- **Catch signals across the whole market.** Leave the ticker empty and it scans every insider trade in the US market, so you can spot heavy buying or selling at companies that aren't on your radar yet — not just look up names you already know. Pass tickers when you do want a specific company's history. Same flat output either way.
- **Cluster buys, detected for you.** Several insiders buying the same stock in the same window is one of the strongest bullish signals there is. The actor groups purchases by company and tells you how many distinct insiders are behind each one, so conviction plays surface on their own instead of you hunting for them.
- **Compact output, every field usable.** Around 25 plain, typed fields per transaction — who, role, buy or sell, price, shares, dollar value, ownership change, dates, and a link to the filing. One row per trade, no nested objects, nothing padded out. A spreadsheet opens clean and an AI agent spends its context on the data instead of parsing it.
- **Complete data when you want it.** Pagination is automatic, so a full month across the whole market or years of a single company's history comes back whole — set `maxResults` as high as you need. Rows come newest-first, so a smaller limit simply keeps the most recent matches.

### What you can do with it

- **Morning market scan**: "Show me all insider purchases over $100k filed in the last 24 hours"
- **Cluster buy signals**: "Which companies had 3+ insiders buying this month?" — one of the strongest documented bullish signals
- **Portfolio monitoring**: "Did any insiders sell at the companies I hold this week?"
- **CEO/CFO conviction tracking**: "Show me C-suite open-market purchases, market-wide"
- **Per-company history**: "Full insider transaction history for NVDA back to 2003"

### Modes

**Market-wide feed** (leave `tickers` empty): latest insider transactions across all US stocks, filtered server-side by trade type, minimum value, insider role, and filing date.

**Ticker mode** (set `tickers`): insider transaction history per company. Set `daysBack: 0` for the full history.

Both modes return the same flat row format, so your downstream code or agent only needs to understand one schema.

### Example input

Market-wide notable buys and sells, last 7 days (this is the default — `{}` works too):

```json
{
    "tradeTypes": ["purchase", "sale"],
    "minTradeValueUsd": 25000,
    "daysBack": 7,
    "maxResults": 5000
}
````

Cluster buys only — companies where 2+ insiders bought:

```json
{
    "clusterBuysOnly": true,
    "minTradeValueUsd": 25000,
    "daysBack": 14
}
```

Per-ticker history:

```json
{
    "tickers": "AAPL, MSFT",
    "daysBack": 0,
    "tradeTypes": ["purchase", "sale"],
    "maxResults": 500
}
```

### Example output (one row per transaction)

```json
{
    "filedAt": "2026-06-11T11:17:33Z",
    "tradeDate": "2026-06-09",
    "ticker": "MTDR",
    "companyName": "Matador Resources Co",
    "insiderName": "Stetson Glenn W",
    "insiderCik": "2020289",
    "insiderTitle": "EVP",
    "insiderRoles": ["officer"],
    "tradeType": "purchase",
    "price": 42.95,
    "quantity": 2400,
    "valueUsd": 103080,
    "sharesOwnedAfter": 26414,
    "ownershipChangePct": 10.0,
    "isClusterBuy": true,
    "clusterInsiderCount": 3,
    "isAmendedFiling": false,
    "isMultipleTransactions": false,
    "hasDerivativeTransactions": false,
    "tradeTypeRaw": "P - Purchase",
    "ownershipChangeRaw": "+10%",
    "flagsRaw": null,
    "secForm4Url": "http://www.sec.gov/Archives/edgar/data/.../wk-form4_1781176650.xml",
    "accessionNumber": "0002020289-26-000006",
    "source": "openinsider"
}
```

### Field notes

- **`filedAt` vs `tradeDate`**: `filedAt` is when the SEC received the filing (freshness; default sort). `tradeDate` is when the insider actually traded — it can lag the filing by days or occasionally much longer.
- **`tradeType`**: open-market `purchase` and `sale` are the meaningful signals. Grants, option exercises, and tax withholdings are compensation mechanics — excluded by default, but available via `tradeTypes`.
- **`quantity` / `valueUsd`** are signed: negative = disposal.
- **`ownershipChangePct`** is null when the source reports `New` (first disclosed stake) or `>999%` — the raw string is preserved in `ownershipChangeRaw`.
- **`accessionNumber`** is the SEC's unique filing ID — use it to deduplicate across scheduled runs.
- **`isAmendedFiling`** (Form 4/A) rows can duplicate the original filing's transaction with corrected values.
- **`hasDerivativeTransactions`**: only non-derivative transactions are returned as rows (open-market buys/sells, grants, etc.). Derivative legs (options, warrants) are **not** emitted as rows — when a filing contains them this flag is `true` so you know there's more in the underlying Form 4 (follow `secForm4Url`). This keeps option-exercise noise out of screens by design; occasionally a real signal lives in the derivative section, so check the filing when the flag is set.

### Cluster buy detection

With `clusterBuysOnly: true`, the actor fetches all qualifying purchases market-wide, groups them by company, and returns only purchases at companies where at least `minClusterInsiders` distinct insiders (matched by SEC CIK) bought within the window. Rows are sorted by cluster size, then filing date.

By default, insiders who are 10%+ owners **without** any officer or director role are excluded from clusters (`excludePureTenPercentOwners`) — a fund accumulating shares is not a management-conviction signal.

### Use with AI agents (MCP)

This actor works as a tool via the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp), so any MCP-compatible agent (Claude, etc.) can call it directly:

```bash
npx @apify/actors-mcp-server --tools michael_b/stock-insider-trading
```

Typical agent calls:

- `{}` → notable insider activity, last 7 days
- `{"clusterBuysOnly": true, "daysBack": 14}` → cluster buy signals
- `{"tickers": "AAPL", "daysBack": 365}` → one year of AAPL insider activity

Rows are compact (~25 fields, no long text). The actor paginates automatically past the source's 5,000-rows-per-request limit, so a long window with loose filters can return tens of thousands of rows; lower `maxResults` to keep responses inside LLM context windows.

### Data source & freshness

Data is parsed from SEC Form 4 filings (via OpenInsider, which indexes EDGAR continuously). New filings typically appear within minutes to hours of hitting EDGAR. Filing timestamps are converted to UTC. Coverage: non-derivative transactions (open-market trades); filings that also contain derivative legs are flagged via `hasDerivativeTransactions`.

### Pricing & cost

Pay per result — the bill is simply rows returned × the per-result price, so cost scales linearly with how many rows come back. A tightly filtered scan (cluster buys, or a single ticker) returns tens to a few hundred rows and costs accordingly; runs are fast (seconds), with no browser or proxies.

**Cost control:** `maxResults` is hard-capped at 100,000, so no single run can exceed that many rows. Keep typical runs cheap with filters — `clusterBuysOnly: true`, a `minTradeValueUsd` floor, a smaller `daysBack`, or a lower `maxResults`. The one case to set deliberately is a high `maxResults` with an unfiltered `daysBack: 0` market-wide scan (all insider history), which is what approaches the ceiling.

### Related actors

- [Stock News Scraper (Finviz)](https://apify.com/michael_b/finviz-ticker-news) — full-text news by ticker
- [Stock Earnings Calendar](https://apify.com/michael_b/stock-earnings-calendar) — earnings dates with EPS/revenue estimates

# Actor input Schema

## `tickers` (type: `string`):

Stock ticker symbols separated by commas (e.g. AAPL, TSLA, NVDA). Leave empty to get a market-wide feed of the latest insider transactions across all US stocks.

## `tradeTypes` (type: `array`):

Which transaction types to include. Open-market purchases and sales are the meaningful signals; grants, option exercises, and tax withholdings are mostly compensation noise.

## `minTradeValueUsd` (type: `integer`):

Only include transactions with an absolute value of at least this many dollars. Set to 0 for no minimum. Values are applied in $1,000 steps.

## `daysBack` (type: `integer`):

Only include transactions FILED within the last N days. Set to 0 for all available history (useful with tickers for full per-company insider history back to ~2003).

## `maxResults` (type: `integer`):

Maximum number of transactions to return (per ticker when tickers are set, total for the market-wide feed). The actor paginates automatically, so this can exceed 5,000. Rows are returned newest-first, so a smaller limit keeps the most recent matches. Lower it to keep output small for LLM context windows.

## `insiderRoles` (type: `array`):

Only include transactions by insiders with at least one of these roles. Leave empty for all insiders. CEO and CFO purchases are typically the strongest signals.

## `clusterBuysOnly` (type: `boolean`):

Market-wide mode only: return only purchases in companies where multiple distinct insiders bought within the time window. Multiple insiders buying with personal money is one of the strongest bullish signals.

## `minClusterInsiders` (type: `integer`):

Minimum number of distinct insiders buying the same stock to count as a cluster. Only used when Cluster Buys Only is enabled.

## `excludePureTenPercentOwners` (type: `boolean`):

When detecting cluster buys, skip insiders who are 10%+ owners without any officer or director role. A fund accumulating a position is not a management-conviction signal. Only used when Cluster Buys Only is enabled.

## Actor input object example

```json
{
  "tradeTypes": [
    "purchase",
    "sale"
  ],
  "minTradeValueUsd": 25000,
  "daysBack": 7,
  "maxResults": 5000,
  "insiderRoles": [],
  "clusterBuysOnly": false,
  "minClusterInsiders": 2,
  "excludePureTenPercentOwners": true
}
```

# Actor output Schema

## `results` (type: `string`):

Dataset of insider transactions: filing and trade dates, ticker, company, insider name and roles, trade type, price, quantity, value, ownership change, cluster-buy flags, and SEC Form 4 links.

# 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": ""
};

// Run the Actor and wait for it to finish
const run = await client.actor("michael_b/stock-insider-trading").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": "" }

# Run the Actor and wait for it to finish
run = client.actor("michael_b/stock-insider-trading").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": ""
}' |
apify call michael_b/stock-insider-trading --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=michael_b/stock-insider-trading",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Stock Insider Trading - SEC Form 4 Buys, Sells & Cluster Buys",
        "description": "Track insider trading from SEC Form 4 filings: insider buys and sells market-wide or per ticker. Filter by trade value, insider role (CEO, CFO, director), and date. Detect cluster buys where multiple insiders buy the same stock. Clean flat JSON for AI agents, LLM pipelines, and trading signals.",
        "version": "0.1",
        "x-build-id": "eVVe2ANTPqaTp4xwl"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/michael_b~stock-insider-trading/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-michael_b-stock-insider-trading",
                "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/michael_b~stock-insider-trading/runs": {
            "post": {
                "operationId": "runs-sync-michael_b-stock-insider-trading",
                "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/michael_b~stock-insider-trading/run-sync": {
            "post": {
                "operationId": "run-sync-michael_b-stock-insider-trading",
                "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": "Ticker Symbols (optional)",
                        "type": "string",
                        "description": "Stock ticker symbols separated by commas (e.g. AAPL, TSLA, NVDA). Leave empty to get a market-wide feed of the latest insider transactions across all US stocks."
                    },
                    "tradeTypes": {
                        "title": "Trade Types",
                        "type": "array",
                        "description": "Which transaction types to include. Open-market purchases and sales are the meaningful signals; grants, option exercises, and tax withholdings are mostly compensation noise.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "purchase",
                                "sale",
                                "saleToIssuer",
                                "optionExercise",
                                "grant",
                                "taxWithholding",
                                "gift",
                                "conversion",
                                "inherited",
                                "other"
                            ],
                            "enumTitles": [
                                "Purchase (open market)",
                                "Sale (open market, incl. sale tied to option exercise)",
                                "Sale to issuer",
                                "Option exercise",
                                "Grant / award",
                                "Tax withholding",
                                "Gift",
                                "Derivative conversion",
                                "Inherited",
                                "Other"
                            ]
                        },
                        "default": [
                            "purchase",
                            "sale"
                        ]
                    },
                    "minTradeValueUsd": {
                        "title": "Minimum Trade Value (USD)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include transactions with an absolute value of at least this many dollars. Set to 0 for no minimum. Values are applied in $1,000 steps.",
                        "default": 25000
                    },
                    "daysBack": {
                        "title": "Days Back (filing date)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include transactions FILED within the last N days. Set to 0 for all available history (useful with tickers for full per-company insider history back to ~2003).",
                        "default": 7
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Maximum number of transactions to return (per ticker when tickers are set, total for the market-wide feed). The actor paginates automatically, so this can exceed 5,000. Rows are returned newest-first, so a smaller limit keeps the most recent matches. Lower it to keep output small for LLM context windows.",
                        "default": 5000
                    },
                    "insiderRoles": {
                        "title": "Insider Roles",
                        "type": "array",
                        "description": "Only include transactions by insiders with at least one of these roles. Leave empty for all insiders. CEO and CFO purchases are typically the strongest signals.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "ceo",
                                "cfo",
                                "coo",
                                "president",
                                "chairman",
                                "generalCounsel",
                                "vicePresident",
                                "officer",
                                "director",
                                "tenPercentOwner",
                                "other"
                            ],
                            "enumTitles": [
                                "CEO",
                                "CFO",
                                "COO",
                                "President",
                                "Chairman of the Board",
                                "General Counsel",
                                "Vice President",
                                "Officer (any)",
                                "Director",
                                "10%+ Owner",
                                "Other"
                            ]
                        },
                        "default": []
                    },
                    "clusterBuysOnly": {
                        "title": "Cluster Buys Only",
                        "type": "boolean",
                        "description": "Market-wide mode only: return only purchases in companies where multiple distinct insiders bought within the time window. Multiple insiders buying with personal money is one of the strongest bullish signals.",
                        "default": false
                    },
                    "minClusterInsiders": {
                        "title": "Min Insiders Per Cluster",
                        "minimum": 2,
                        "type": "integer",
                        "description": "Minimum number of distinct insiders buying the same stock to count as a cluster. Only used when Cluster Buys Only is enabled.",
                        "default": 2
                    },
                    "excludePureTenPercentOwners": {
                        "title": "Exclude Pure 10% Owners From Clusters",
                        "type": "boolean",
                        "description": "When detecting cluster buys, skip insiders who are 10%+ owners without any officer or director role. A fund accumulating a position is not a management-conviction signal. Only used when Cluster Buys Only is enabled.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```