# Enforcement Record Profiler — Company Violations & Lawsuits (`shelvick/enforcement-record-profiler`) Actor

Compiles a cited enforcement and accountability profile for a company or organization from official U.S. public records — federal courts, the DOJ, FTC, OSHA, and NLRB. Every finding links to its official source. Public records on organizations only; one entity per run.

- **URL**: https://apify.com/shelvick/enforcement-record-profiler.md
- **Developed by:** [Scott Helvick](https://apify.com/shelvick) (community)
- **Categories:** News, Agents
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.255 / profile compiled

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Enforcement Record Profiler — Company Violations & Lawsuits

Checking whether a company has a record of regulatory or legal trouble means searching a dozen government sites by hand — each with its own quirks — and stitching the results together. Enforcement Record Profiler does it in one call: name an organization, get back a single **cited** report of its enforcement and accountability record across federal agencies and the courts, with every finding linked to its official source.

### What this does

Submit one organization name. The Actor resolves it to a canonical identity, searches the official public-record sources below, and returns a structured, citation-grounded profile.

- **Entity resolution** — maps the name you give to a canonical identity (official name, known aliases, and SEC CIK + stock ticker when the entity is a public registrant), so findings attach to the right company.
- **Multi-source search across official records:**
  - **Federal courts** — dockets and opinions naming the entity (via CourtListener/RECAP).
  - **U.S. Department of Justice (DOJ)** — press-released charges, indictments, pleas, settlements, and judgments.
  - **U.S. Securities and Exchange Commission (SEC)** — recent enforcement actions: litigation releases, administrative proceedings, and accounting-and-auditing enforcement. Covers the agency's current enforcement window rather than its full case history.
  - **Federal Trade Commission (FTC)** — consumer-protection, deceptive/unfair-practice, antitrust, and privacy cases.
  - **OSHA** — workplace-safety inspections and citations.
  - **National Labor Relations Board (NLRB)** — unfair-labor-practice charges and representation/election cases naming the entity.
  - **Environmental Protection Agency (EPA)** — federal environmental enforcement cases (Clean Air Act, Clean Water Act, RCRA, CERCLA/Superfund, TSCA, and more) naming the entity, with penalties and cleanup cost-recovery amounts.
- **Per-claim citations** — every finding carries the source agency, a title, the date, a penalty/settlement amount when shown, and the **exact source URL**. Nothing is asserted without a link.
- **Neutral summary** — a plain-language synthesis of the record across sources, describing what the documents state (not conclusions about guilt).
- **Source-coverage audit** — for each source: whether it was queried, how many findings it produced, and a note if it was unavailable.
- **Three outputs per run** — a machine-readable dataset record, a human-readable Markdown report (`OUTPUT` in the run's Key-Value Store), and the raw findings as JSON (`RAW_FINDINGS`).

Common workflows this enables:

- A journalist building a sourced timeline of a company's misconduct before filing a story.
- A vendor-risk or ESG analyst screening a supplier or portfolio company for enforcement history.
- A litigation-support researcher pulling the federal cases and agency actions tied to an entity.
- An academic or watchdog compiling accountability data across many organizations.
- An activist investor assembling the regulatory record ahead of an engagement.

### Why cited, multi-source profiling matters

The signal an analyst or reporter actually needs — "what has this organization been held accountable for, and where is the proof?" — is scattered across agencies that each publish differently. Doing it by hand is slow and easy to get wrong: miss one agency and you miss the story.

The worse failure mode is the tempting shortcut: ask a general-purpose model "what has Company X done wrong?" and get a fluent paragraph that invents a settlement, misstates a penalty, or cites a URL that doesn't exist. For accountability work, an unverifiable claim is worse than no claim — it's a correction or a libel risk.

This Actor is built the opposite way. It fetches the official agency and court pages, extracts **only** what is present on them, and attaches the real source link to every finding. The summary is generated from those cited findings, not from model memory. If a source has nothing, the report says so rather than filling the gap. You get something you can publish or hand to counsel, because every line traces back to a government record.

### How it compares

| Approach | Multi-agency in one pass | Per-claim citations | Grounded in official records | Agent-callable |
|---|---|---|---|---|
| Manual search across agency sites | ✗ (one at a time) | ✓ (you copy them) | ✓ | ✗ |
| General web-search LLM | partial | ✗ (often fabricated) | ✗ | partial |
| Subscription compliance/diligence suites | ✓ | ✓ | ✓ | ✗ (seat-licensed) |
| **Enforcement Record Profiler** | ✓ | ✓ | ✓ | ✓ |

The distinguishing combination is *unified, cited, official-source-grounded, and callable by an agent or a script per profile* — without a seat license or a manual multi-site slog.

### Input

| Field | Type | Required | Default | Description |
|---|---|---|---|---|
| `entity` | string | ✓ | — | Legal name of the organization to profile (one entity per run). Add a parenthetical hint if the name is ambiguous, e.g. `"Acme Corp (Delaware)"` or a ticker. Organizations and public figures acting in an official capacity only — not private individuals. |
| `sources` | array of strings | | all | Subset of sources to query. Valid values: `courts`, `doj`, `sec`, `ftc`, `osha`, `nlrb`, `epa`. Omit to query all. Invalid values are rejected with a clear error. |
| `sinceYear` | integer | | — | Only include findings dated on or after this year. Omit for no lower bound. Narrowing reduces noise and cost. |
| `maxRecordsPerSource` | integer | | `25` | Cap on findings returned per source (1–200). Bounds run cost and filters low-signal volume. |

### Output

One dataset record per run, plus a Markdown report at `OUTPUT` and raw findings at `RAW_FINDINGS` in the run's Key-Value Store.

```json
{
  "entity": "Wells Fargo & Company",
  "resolved_identity": {
    "name": "WELLS FARGO & COMPANY/MN",
    "aliases": ["Wells Fargo & Company"],
    "cik": "0000072971",
    "ticker": "WFC",
    "subsidiaries": []
  },
  "summary": "Across the queried records, federal regulators and courts show multiple actions, including consumer-protection settlements and labor and safety matters. See findings for sourced detail.",
  "total_findings": 23,
  "findings": [
    {
      "source": "doj",
      "title": "Company agrees to civil settlement over billing practices",
      "date": "2020-02-21",
      "category": "criminal/civil",
      "summary": "Settled civil matter; the company agreed to a payment without admitting liability.",
      "amount_usd": 3000000000,
      "url": "https://www.justice.gov/opa/pr/example",
      "document_title": "Office of Public Affairs press release"
    }
  ],
  "source_coverage": [
    { "source": "courts", "queried": true, "findings_count": 12, "note": null },
    { "source": "sec", "queried": true, "findings_count": 0, "note": "no matching SEC enforcement actions in the current feed window" }
  ],
  "warnings": [],
  "generated_at": "2026-05-29T14:03:11Z"
}
````

Every field is documented on the Console's Dataset tab. The `OUTPUT` Markdown report renders the same data as a sourced, readable document.

### Example

```json
{
  "entity": "Wells Fargo & Company",
  "sources": ["courts", "doj", "sec", "ftc", "osha"],
  "sinceYear": 2015
}
```

Via the API:

```bash
curl -X POST "https://api.apify.com/v2/acts/shelvick~enforcement-record-profiler/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"entity": "Wells Fargo & Company", "sinceYear": 2015}'
```

### Calling from an AI agent

The Actor is built for agent discovery and invocation.

**MCP** (`mcp.apify.com`): surfaces as a callable tool. The input schema is self-documenting — one required field (`entity`), structured cited output, no follow-up questions — so an LLM can construct correct calls from the tool description alone. Pay per call via the Actor's pay-per-event model, which works with x402 (USDC on Base) and Skyfire managed-token agentic-payment rails.

**Apify SDK** (Python):

```python
from apify_client import ApifyClient

client = ApifyClient(token=API_TOKEN)
run = client.actor("shelvick/enforcement-record-profiler").call(
    run_input={"entity": "Wells Fargo & Company", "sinceYear": 2015}
)
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["total_findings"], "findings")
    for f in item["findings"]:
        print(f["source"], f["date"], f["title"], "->", f["url"])
```

**REST**: `/run-sync-get-dataset-items` for typical runs; for large entities that query every source, prefer the async `/runs` endpoint (a full multi-source profile can approach the 5-minute sync cap).

### Pricing

Pay-per-event. One charge fires per **successful** run, after the cited profile is pushed — it covers entity resolution, every selected source query, and the report synthesis. Failed runs are never charged, and the platform startup charge is effectively zero. Subscriber tiers receive a discount.

See the **Pricing** tab on this Store page for the current per-event rate and any active subscriber discounts.

### Behavior

**Run-level failures (rare)** — only input validation fails a run:

- `entity` missing or shorter than two characters.
- `sources` contains a value outside `courts` / `doj` / `sec` / `ftc` / `osha` / `nlrb` / `epa`.

**Per-source degradation (expected)** — a source that is unreachable, rate-limited, or returns nothing never fails the run. It is recorded in `source_coverage` with a note, and an entry is added to `warnings`. The profile is built from whatever sources did respond. Findings are never invented to fill a gap.

**Performance** — runtime is set by the slowest selected source. Most return in seconds, and a full multi-source profile typically completes in well under a minute; a single-source run (e.g. `["courts"]`) is nearly instant. The NLRB and EPA records are served from indexes refreshed on a schedule, so they answer fast at query time rather than waiting on the source agencies — the trade-off is freshness (a filing from the last few days may not be indexed yet). A very large entity queried across every source can still approach the 5-minute sync-API cap; use the async endpoint when batching.

### FAQ

**Which sources are covered?**
Federal courts (CourtListener/RECAP), DOJ, SEC (recent enforcement window), FTC, OSHA, NLRB, and EPA (federal environmental enforcement).

**Does it profile individual people?**
No. Scope is strictly organizations and public figures acting in an official capacity — not private-individual background checks.

**Can the summary invent findings?**
No. Findings are extracted only from the official agency and court pages the Actor fetches, and every finding carries the source URL. The summary is written from those cited findings. Always verify against the linked sources before relying on a finding.

**Does it scrape PACER or state courts?**
No. Court coverage is federal, via CourtListener/RECAP. Direct PACER and state-court portals are out of scope.

**Do failed runs cost anything?**
No. The per-profile charge fires only after a successful run pushes its record; failed runs skip it.

**Can I profile several companies at once?**
No — one entity per run. Run several and combine the dataset records yourself.

### What this doesn't do

- **No private-individual investigation.** Organizations and public figures in an official capacity only.
- **EPA coverage is federal environmental enforcement.** Civil, administrative, and judicial cases from EPA's federal enforcement docket (Clean Air/Water Act, RCRA, CERCLA, TSCA, etc.), refreshed weekly. State environmental agencies and real-time updates are out of scope.
- **No PACER or state-court scraping.** Federal dockets come through CourtListener/RECAP; state courts are not covered.
- **No legal advice or guilt determination.** The Actor reports what the public record states and links to it; interpretation is yours.
- **No continuous monitoring.** Each run is a one-shot profile, not a standing alert.

For individual background checks, use a person-records service (this Actor deliberately does not). For full regulatory **compliance** or sanctions screening, use a dedicated compliance platform. For ongoing change alerts on an entity, pair this with a scheduling/monitoring workflow that re-runs it and diffs the results.

***

Design notes: [www.scotthelvick.com/tools/enforcement-record-profiler](https://www.scotthelvick.com/tools/enforcement-record-profiler)

# Actor input Schema

## `entity` (type: `string`):

Legal name of the company or organization to profile (one entity per run). Add a short parenthetical hint if the name is ambiguous, e.g. 'Acme Corp (Delaware)' or a stock ticker, to improve entity resolution. Profiles cover organizations and public figures acting in an official capacity only — not private individuals.

## `sources` (type: `array`):

Which official sources to search. Valid values: sec, ftc, osha, epa, nlrb, doj, courts. 'courts' uses federal dockets via CourtListener/RECAP. Omit to query all sources. Invalid values are rejected at runtime with a clear error.

## `sinceYear` (type: `integer`):

Only include findings dated on or after this year. Omit for no lower bound. Narrowing the window reduces noise and run cost.

## `maxRecordsPerSource` (type: `integer`):

Cap on the number of findings returned per source (1-200). Bounds run cost and filters low-signal volume. Defaults to 25.

## Actor input object example

```json
{
  "entity": "Wells Fargo & Company",
  "sources": [
    "sec",
    "ftc",
    "osha",
    "epa",
    "nlrb",
    "doj",
    "courts"
  ],
  "sinceYear": 2015,
  "maxRecordsPerSource": 25
}
```

# Actor output Schema

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

Dataset items for this run.

# 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 = {
    "entity": "Wells Fargo & Company",
    "sources": [
        "sec",
        "ftc",
        "osha",
        "epa",
        "nlrb",
        "doj",
        "courts"
    ],
    "sinceYear": 2015,
    "maxRecordsPerSource": 25
};

// Run the Actor and wait for it to finish
const run = await client.actor("shelvick/enforcement-record-profiler").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 = {
    "entity": "Wells Fargo & Company",
    "sources": [
        "sec",
        "ftc",
        "osha",
        "epa",
        "nlrb",
        "doj",
        "courts",
    ],
    "sinceYear": 2015,
    "maxRecordsPerSource": 25,
}

# Run the Actor and wait for it to finish
run = client.actor("shelvick/enforcement-record-profiler").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 '{
  "entity": "Wells Fargo & Company",
  "sources": [
    "sec",
    "ftc",
    "osha",
    "epa",
    "nlrb",
    "doj",
    "courts"
  ],
  "sinceYear": 2015,
  "maxRecordsPerSource": 25
}' |
apify call shelvick/enforcement-record-profiler --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=shelvick/enforcement-record-profiler",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Enforcement Record Profiler — Company Violations & Lawsuits",
        "description": "Compiles a cited enforcement and accountability profile for a company or organization from official U.S. public records — federal courts, the DOJ, FTC, OSHA, and NLRB. Every finding links to its official source. Public records on organizations only; one entity per run.",
        "version": "0.0",
        "x-build-id": "NTTCFSIRINCSYuW5c"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/shelvick~enforcement-record-profiler/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-shelvick-enforcement-record-profiler",
                "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/shelvick~enforcement-record-profiler/runs": {
            "post": {
                "operationId": "runs-sync-shelvick-enforcement-record-profiler",
                "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/shelvick~enforcement-record-profiler/run-sync": {
            "post": {
                "operationId": "run-sync-shelvick-enforcement-record-profiler",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "entity"
                ],
                "properties": {
                    "entity": {
                        "title": "Organization name",
                        "type": "string",
                        "description": "Legal name of the company or organization to profile (one entity per run). Add a short parenthetical hint if the name is ambiguous, e.g. 'Acme Corp (Delaware)' or a stock ticker, to improve entity resolution. Profiles cover organizations and public figures acting in an official capacity only — not private individuals."
                    },
                    "sources": {
                        "title": "Sources to query",
                        "type": "array",
                        "description": "Which official sources to search. Valid values: sec, ftc, osha, epa, nlrb, doj, courts. 'courts' uses federal dockets via CourtListener/RECAP. Omit to query all sources. Invalid values are rejected at runtime with a clear error.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "sinceYear": {
                        "title": "Earliest year",
                        "type": "integer",
                        "description": "Only include findings dated on or after this year. Omit for no lower bound. Narrowing the window reduces noise and run cost."
                    },
                    "maxRecordsPerSource": {
                        "title": "Max records per source",
                        "type": "integer",
                        "description": "Cap on the number of findings returned per source (1-200). Bounds run cost and filters low-signal volume. Defaults to 25.",
                        "default": 25
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```