# 🔒 SEC Going-Private Transaction Tracker (`nexgendata/sec-going-private-tracker`) Actor

SEC going-private (SC 13E3) and merger proxy (DEFM14A/PREM14A) filings

- **URL**: https://apify.com/nexgendata/sec-going-private-tracker.md
- **Developed by:** [NexGenData](https://apify.com/nexgendata) (community)
- **Categories:** Business
- **Stats:** 5 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $50.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

## 🔒 SEC Going-Private Transaction Tracker — 13E3, DEFM14A & PREM14A Filings

**Pay-per-result SEC going-private intelligence — $0.10 per filing. No Bloomberg terminal, no Refinitiv deals desk, no per-seat licence. The entire SC 13E3 / merger-proxy deal flow, delivered as flat JSON from the official EDGAR full-text search.**

When a public company gets taken private — a private-equity buyout, a controlling-shareholder squeeze-out, a management-led LBO — the legal trail runs through a specific cluster of SEC forms: the Schedule 13E-3 going-private statement, and the definitive and preliminary merger proxies (DEFM14A and PREM14A) that solicit the shareholder vote. These filings are where the deal terms, the fairness opinion, the buyer identity, and the merger consideration are first disclosed publicly. For M&A arbitrageurs, deal lawyers, PE deal teams, and event-driven funds, catching them the day they hit EDGAR is the difference between front-running the news and reading it in the paper.

This actor monitors EDGAR's full-text search for exactly those form types and returns a clean record per filing: the filer's company name, ticker, the precise form type, the filed date, and a direct link to the source document on SEC.gov. Filter by form type, add an optional keyword to AND against the form filter, look back a configurable number of days, or pin an exact date window — then pull every going-private and merger-proxy filing that matched.

### Why use this

Bloomberg and Refinitiv both surface going-private deals, but they cost \$24K+ per seat per year and lock the data behind a terminal you cannot pipe into your own models. EDGAR itself is free, but the full-text search is a manual, paginated web UI that does not export, does not dedupe, does not normalize form types, and does not hand you a ticker or a clean document URL. Building and maintaining your own EDGAR scraper means handling pagination, the SEC's User-Agent fair-access policy, rate limits, and the quirks of full-text vs filing-index search.

This actor is the middle path: the official EDGAR data, normalized into structured JSON, filtered to exactly the going-private and merger-proxy forms you care about, for cents per filing. You set a form list, an optional keyword, and a date window; you get back deduplicated, ETL-ready rows. Because billing is pay-per-result, a tightly-scoped daily monitor that surfaces 3 new filings costs you for 3 records — not for a terminal subscription you pay whether or not a deal printed.

### What you get

Every record represents one SEC filing and carries exactly these fields:

- `companyName` — the filer's company name as recorded on EDGAR
- `ticker` — the issuer's stock ticker (when resolvable from the filing)
- `formType` — the precise SEC form (e.g. `SC 13E3`, `DEFM14A`, `PREM14A`)
- `filedDate` — the date the filing hit EDGAR
- `documentUrl` — a direct link to the source filing document on SEC.gov

Records are flat JSON, ready for Snowflake, BigQuery, Postgres, a pandas DataFrame, or your deal-flow CRM without remapping.

### Use cases

- **Merger-arbitrage deal sourcing** — Run a daily monitor on `SC 13E3, DEFM14A, PREM14A` with a short `daysBack` window and route every new filing to your arb desk. A fresh 13E-3 is the canonical signal that a going-private deal has been formalized — get the ticker and the document URL before the market fully prices it.
- **PE deal-team competitive intelligence** — Track which sponsors are taking which companies private. Pull the merger proxies, extract the buyer and consideration from the linked document, and map the competitive landscape of going-private activity in your target sectors.
- **Deal-lawyer precedent research** — Filter to `DEFM14A` / `PREM14A` and use the `query` keyword to AND in a deal feature (a structure, a clause, a party name) to build a precedent set of comparable merger proxies for drafting and negotiation.
- **Event-driven fund monitoring** — Add `SC 13E3` filings to your event calendar the day they file. The `filedDate` field anchors your event window; the `documentUrl` gives your analysts the primary source.
- **Squeeze-out / minority-shareholder watch** — Controlling-shareholder going-private transactions trigger 13E-3 disclosure and fairness-opinion requirements. Monitor for them to flag minority-shareholder situations and appraisal-rights opportunities.
- **Corporate-development pipeline tracking** — Corp-dev teams can watch peers and targets for going-private signals, feeding the `companyName` + `ticker` + `filedDate` rows straight into their M&A pipeline tracker.
- **Academic / market-structure research** — Build a longitudinal dataset of going-private activity by setting an explicit `startDate` / `endDate` window and pulling the full population of 13E-3 and merger-proxy filings across the period.

### Sample output

```json
{
  "companyName": "EXAMPLE HOLDINGS CORP",
  "ticker": "EXHC",
  "formType": "SC 13E3",
  "filedDate": "2026-06-18",
  "documentUrl": "https://www.sec.gov/Archives/edgar/data/0001234567/000123456726000045/sc13e3.htm"
}
````

A merger-proxy filing for the same kind of deal:

```json
{
  "companyName": "EXAMPLE HOLDINGS CORP",
  "ticker": "EXHC",
  "formType": "DEFM14A",
  "filedDate": "2026-06-20",
  "documentUrl": "https://www.sec.gov/Archives/edgar/data/0001234567/000123456726000051/defm14a.htm"
}
```

### Input parameters

| Parameter | Type | Description |
|---|---|---|
| `forms` | string | Comma-separated list of SEC going-private / merger-proxy form types to monitor (e.g. `SC 13E3, DEFM14A, PREM14A`). |
| `query` | string | Optional exact-phrase keyword to AND against the form filter — narrows results to filings whose text contains the phrase. |
| `daysBack` | integer | Look back this many days from today (ignored if `startDate` / `endDate` are set). |
| `startDate` | string | Override the window start (`YYYY-MM-DD`). |
| `endDate` | string | Override the window end (`YYYY-MM-DD`). |
| `maxResults` | integer | Maximum number of filings to return. Bounds result size and cost. |
| `userAgentContact` | string | A contact string (name + email) sent as the SEC-required User-Agent. SEC fair-access policy requires every request to identify a contact. |

### How to use

#### Python (apify-client)

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")

run = client.actor("nexgendata/sec-going-private-tracker").call(run_input={
    "forms": "SC 13E3, DEFM14A, PREM14A",
    "daysBack": 7,
    "maxResults": 100,
    "userAgentContact": "Your Name your-email@example.com",
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["filedDate"], item["formType"], item["companyName"], item["documentUrl"])
```

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/nexgendata~sec-going-private-tracker/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "forms": "SC 13E3, DEFM14A, PREM14A",
    "daysBack": 7,
    "maxResults": 100,
    "userAgentContact": "Your Name your-email@example.com"
  }'
```

Schedule it daily on Apify's built-in scheduler for a standing going-private monitor, and wire a webhook into Slack / n8n / your deal CRM so a fresh 13E-3 hits your desk the moment it files.

### Pricing

This actor runs on Apify's **pay-per-event** model — you pay only for results:

- **$0.10 per filing record** — the primary event, charged once per filing pushed to the dataset
- **No subscription, no seat licence, no minimum commitment**

#### Cost worked example

- A daily monitor that surfaces 4 new going-private filings → 4 × $0.10 = **$0.40** per day
- A 90-day historical backfill returning 60 filings → 60 × $0.10 = **$6.00**
- A quiet day with no new filings → **$0.00**

You set `daysBack` / date window and `maxResults`, so you control cost before the run. Browse 200+ buyer-intent actors at https://apify.com/nexgendata?fpr=2ayu9b

### How this compares to Bloomberg

| Platform | Going-private coverage | Annual cost | Programmatic export |
|---|---|---|---|
| Bloomberg Terminal (M\&A / deal monitor) | Curated global deals + analytics | ~$24,000 / seat / year | Seat-locked (BLPAPI) |
| Refinitiv / LSEG Deals | Curated global M\&A database | Custom enterprise contract | API, enterprise-priced |
| EDGAR full-text search (DIY) | Complete US filings | Free | None — manual paginated web UI, no ticker, no normalization |
| **Going-Private Tracker (this actor)** | **US 13E-3 + merger proxies from EDGAR** | **$0.10 per filing, no subscription** | **Apify REST API + webhooks; flat JSON with ticker + document URL** |

Bloomberg gives you a curated, analyst-enriched deal database and a full terminal — and you pay terminal money for it whether or not a deal printed this week. This actor gives you the official primary-source filings, normalized and ticker-tagged, for cents each. If your workflow is "alert me to new US going-private filings and hand me the source document," you do not need a $24K seat — you need this feed.

### FAQ

**Q: How fresh is the data?**

A: Each run queries EDGAR live, so it reflects filings indexed up to run time. EDGAR's full-text index typically surfaces new filings within a short window of acceptance. For deal-sourcing use, schedule a daily (or intraday) run.

**Q: What is a Schedule 13E-3?**

A: It is the SEC going-private statement filed under Rule 13e-3 when an affiliate (such as a controlling shareholder or management) takes a public company private. It requires fairness disclosures and is the canonical signal that a going-private transaction has been formalized.

**Q: What is the difference between DEFM14A and PREM14A?**

A: PREM14A is the *preliminary* merger proxy filed for SEC review; DEFM14A is the *definitive* merger proxy sent to shareholders to solicit the vote. Tracking both catches a deal at the preliminary stage and again when terms are finalized.

**Q: Why do I need to supply a User-Agent contact?**

A: The SEC's fair-access policy requires every automated request to identify a contact (name + email) so they can reach the operator. Pass yours in `userAgentContact`; the actor sends it on every request.

**Q: Can I get the deal terms (price, buyer) directly?**

A: The actor returns the filing metadata and a direct `documentUrl` to the source. Deal terms — consideration, buyer identity, fairness opinion — live inside the filing document; follow the URL and parse the document (or run it through an LLM) downstream.

**Q: Can I filter to a single sector or company?**

A: Use the `query` keyword to AND an exact phrase against the form filter (a company name or deal term). For a full sector sweep, pull the form types over a date window and filter the `companyName` / `ticker` rows downstream.

### Schema stability & versioning

This actor follows NexGenData's **additive-only schema** contract:

- New fields may be **added** at any time — they appear as new keys defaulting to `null` for older runs.
- Existing fields (`companyName`, `ticker`, `formType`, `filedDate`, `documentUrl`) are **never renamed or removed** without a major-version bump and an advance changelog notice.
- Field semantics (date formats, form-type strings) are **never silently changed**.

Build your deal-flow ETL on this schema with confidence. Report anything unexpected via the actor's Apify Issues tab.

### Compliance & legal

- The actor reads **public, unauthenticated** SEC EDGAR data — the same filings any browser can open on SEC.gov.
- Every request identifies a contact via the SEC-required User-Agent, in line with SEC fair-access policy.
- All requests route through Apify's compliant infrastructure with polite pacing.
- This actor is a **data tool, not investment, legal, or M\&A advice**. Filings are primary-source documents; verify deal specifics in the underlying document before acting.
- You are responsible for downstream-use compliance with applicable data-protection and securities laws.

### Related NexGenData actors

Part of NexGenData's **SEC / Disclosure** suite — pair this actor with:

- [SEC Tender Offer & M\&A Tracker](https://apify.com/nexgendata/sec-tender-offer-ma-tracker?fpr=2ayu9b) — tender-offer and acquisition filings
- [SEC Delisting & Deregistration Tracker](https://apify.com/nexgendata/sec-delisting-deregistration-tracker?fpr=2ayu9b) — Form 25 / Form 15 exits from public markets
- [SEC 8-K Event Monitor](https://apify.com/nexgendata/sec-8k-event-monitor?fpr=2ayu9b) — material-event filings, often the first hint of a deal
- [SEC Activist Proxy Solicitation Tracker](https://apify.com/nexgendata/sec-activist-proxy-solicitation-tracker?fpr=2ayu9b) — activist and contested-proxy campaigns
- [SEC IPO Prospectus Tracker](https://apify.com/nexgendata/sec-ipo-prospectus-tracker?fpr=2ayu9b) — the public-market entrances, the counterpart to going-private exits
- [SEC Exec Comp Proxy Tracker](https://apify.com/nexgendata/sec-exec-comp-proxy-tracker?fpr=2ayu9b) — executive-compensation disclosures from proxy statements

Explore the full catalog of 200+ buyer-intent actors at **https://apify.com/nexgendata?fpr=2ayu9b**.

# Actor input Schema

## `forms` (type: `string`):

Comma-separated SEC going-private/merger-proxy forms.

## `query` (type: `string`):

Optional exact-phrase to AND with the form filter.

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

Look back this many days (ignored if dates set).

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

Override start (YYYY-MM-DD).

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

Override end (YYYY-MM-DD).

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

Maximum filings to return.

## `userAgentContact` (type: `string`):

SEC requires a UA with contact info.

## Actor input object example

```json
{
  "forms": "SC 13E3,DEFM14A,PREM14A",
  "daysBack": 90,
  "maxResults": 300
}
```

# 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 = {
    "forms": "SC 13E3,DEFM14A,PREM14A"
};

// Run the Actor and wait for it to finish
const run = await client.actor("nexgendata/sec-going-private-tracker").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 = { "forms": "SC 13E3,DEFM14A,PREM14A" }

# Run the Actor and wait for it to finish
run = client.actor("nexgendata/sec-going-private-tracker").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 '{
  "forms": "SC 13E3,DEFM14A,PREM14A"
}' |
apify call nexgendata/sec-going-private-tracker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=nexgendata/sec-going-private-tracker",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "🔒 SEC Going-Private Transaction Tracker",
        "description": "SEC going-private (SC 13E3) and merger proxy (DEFM14A/PREM14A) filings",
        "version": "0.0",
        "x-build-id": "RjoY2Nq21POB9yFYN"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/nexgendata~sec-going-private-tracker/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-nexgendata-sec-going-private-tracker",
                "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/nexgendata~sec-going-private-tracker/runs": {
            "post": {
                "operationId": "runs-sync-nexgendata-sec-going-private-tracker",
                "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/nexgendata~sec-going-private-tracker/run-sync": {
            "post": {
                "operationId": "run-sync-nexgendata-sec-going-private-tracker",
                "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": {
                    "forms": {
                        "title": "Form types",
                        "type": "string",
                        "description": "Comma-separated SEC going-private/merger-proxy forms.",
                        "default": "SC 13E3,DEFM14A,PREM14A"
                    },
                    "query": {
                        "title": "Keyword (optional)",
                        "type": "string",
                        "description": "Optional exact-phrase to AND with the form filter."
                    },
                    "daysBack": {
                        "title": "Days back",
                        "minimum": 1,
                        "maximum": 3650,
                        "type": "integer",
                        "description": "Look back this many days (ignored if dates set).",
                        "default": 90
                    },
                    "startDate": {
                        "title": "Start date",
                        "type": "string",
                        "description": "Override start (YYYY-MM-DD)."
                    },
                    "endDate": {
                        "title": "End date",
                        "type": "string",
                        "description": "Override end (YYYY-MM-DD)."
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum filings to return.",
                        "default": 300
                    },
                    "userAgentContact": {
                        "title": "SEC User-Agent contact",
                        "type": "string",
                        "description": "SEC requires a UA with contact info."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```