# FTC Enforcement Actions Scraper (`automation-lab/ftc-enforcement-actions-scraper`) Actor

⚖️ Scrape FTC enforcement actions, cases, proceedings, matter numbers, statuses, summaries, updates, and detail links for compliance monitoring.

- **URL**: https://apify.com/automation-lab/ftc-enforcement-actions-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## FTC Enforcement Actions Scraper

Scrape FTC enforcement actions, cases, proceedings, matter numbers, statuses, summaries, updates, and detail links from the FTC Legal Library.

### What does FTC Enforcement Actions Scraper do?

FTC Enforcement Actions Scraper turns the public FTC cases and proceedings listing into structured data.

It extracts case titles, source URLs, record types, summaries, action types, last updated dates, matter/file numbers, case statuses, and optional detail-page links.

Use it when you need repeatable monitoring of FTC enforcement activity without manually opening the FTC website.

### Who is it for?

- ⚖️ Law firms tracking FTC litigation and administrative proceedings.
- 🛡️ Compliance teams monitoring regulatory risk by company, topic, or status.
- 📰 Journalists following new FTC enforcement developments.
- 📊 Risk intelligence teams building alerts and dashboards.
- 🏛️ Policy researchers studying competition and consumer protection enforcement.

### Why use this actor?

The FTC site is public, but the data is spread across paginated HTML pages and case detail pages.

This actor gives you a clean dataset that can be exported to JSON, CSV, Excel, or connected to downstream workflows.

You can run it on a schedule to monitor new cases and filter by keyword, action type, status, matter number, or date range.

### Data you can extract

| Field | Description |
| --- | --- |
| `title` | FTC case or proceeding title |
| `detailUrl` | Canonical FTC detail page URL |
| `recordTypes` | FTC record type labels |
| `summary` | Listing or detail summary |
| `actionType` | Federal, Administrative, or Process Enforcement when available |
| `lastUpdated` | Human-readable FTC last updated date |
| `lastUpdatedIso` | ISO timestamp from FTC markup when available |
| `matterNumber` | FTC Matter/File Number |
| `caseStatus` | Pending, closed, under order, or other FTC status |
| `topics` | Topic labels found on detail pages |
| `documents` | Related FTC document links when detail fetching is enabled |
| `pressReleases` | Related FTC press release links when detail fetching is enabled |
| `sourceUrl` | Listing URL that produced the record |
| `scrapedAt` | Scrape timestamp |

### How much does it cost to scrape FTC enforcement actions?

This actor uses pay-per-event pricing.

You pay a small start fee per run and a per-record charge for each FTC case or proceeding saved.

The default input is intentionally small so your first run is inexpensive.

For large monitoring jobs, set `maxItems` to the number of records you actually need.

### How to scrape FTC enforcement actions

1. Open the actor on Apify.
2. Keep the prefilled FTC cases/proceedings start URL.
3. Enter a keyword such as a company name, product category, or matter number.
4. Optionally select action types or case status.
5. Set `maxItems`.
6. Turn on `includeDetails` if you need documents and press releases.
7. Run the actor.
8. Download the dataset or connect it to your workflow.

### Input options

#### Start URLs

Use `startUrls` to provide FTC cases/proceedings listing URLs.

The default URL is:

`https://www.ftc.gov/legal-library/browse/cases-proceedings`

#### Keyword search

Use `search` to search by company name, individual name, keyword, or case number.

Examples:

- `Amazon`
- `Kochava`
- `data security`
- `merger`

#### Action type filters

Use `actionTypes` to filter by FTC action type.

Supported values:

- `Federal`
- `Administrative`
- `ProcessEnforcement`

#### Case status filter

Use `caseStatus` to narrow the results.

Supported values include:

- `pending`
- `closed`
- `under_order`
- `on_appeal`

#### Matter number search

Use `matterNumber` when you already know the FTC Matter/File Number.

#### Date range

Use `startDate` and `endDate` in `MM/DD/YYYY` format.

#### Detail enrichment

Set `includeDetails` to `true` to fetch each case detail page.

This can add topics, documents, and press release links.

It is slower than listing-only mode because it performs one extra request per case.

### Example input

```json
{
  "startUrls": [
    { "url": "https://www.ftc.gov/legal-library/browse/cases-proceedings" }
  ],
  "search": "Amazon",
  "maxItems": 25,
  "includeDetails": false
}
````

### Example output

```json
{
  "title": "Amazon.com, Inc., U.S. v.",
  "detailUrl": "https://www.ftc.gov/legal-library/browse/cases-proceedings/252-3024-amazoncom-inc-us-v",
  "recordTypes": ["Cases and Proceedings"],
  "summary": "Amazon will pay $2.25 million in civil penalties...",
  "actionType": "Federal",
  "lastUpdated": "June 30, 2026",
  "lastUpdatedIso": "2026-06-30T12:00:00Z",
  "matterNumber": "252 3024",
  "caseStatus": "Pending",
  "topics": [],
  "documents": [],
  "pressReleases": [],
  "sourceUrl": "https://www.ftc.gov/legal-library/browse/cases-proceedings?...",
  "scrapedAt": "2026-07-01T00:00:00.000Z"
}
```

### Tips for better results

- Use a company name for focused monitoring.
- Use `caseStatus` for workflows that only care about pending or active matters.
- Keep `includeDetails` off for fast broad scans.
- Turn `includeDetails` on for research packs, legal memos, or document collection.
- Use `maxItems` to control cost and runtime.

### Common workflows

#### FTC company monitor

Schedule a daily run with a company name in `search`.

Export the dataset to your alerting or BI tool.

#### Pending cases dashboard

Run with `caseStatus` set to `pending` and `sortBy` set to newest.

Use the dataset to power a dashboard of current enforcement activity.

#### Matter-number lookup

Use `matterNumber` when a filing, press release, or client alert references a specific FTC number.

#### Document collection

Enable `includeDetails` for a narrow search to collect related FTC document links.

### Integrations

You can connect this actor to:

- Google Sheets for regulatory trackers.
- Slack alerts through Apify integrations.
- Zapier or Make for compliance workflows.
- BI dashboards using the dataset API.
- Internal legal data lakes using Apify API clients.

### API usage

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/ftc-enforcement-actions-scraper').call({
  search: 'Amazon',
  maxItems: 25,
});
console.log(run.defaultDatasetId);
```

#### Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/ftc-enforcement-actions-scraper').call({
    'search': 'Amazon',
    'maxItems': 25,
})
print(run['defaultDatasetId'])
```

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~ftc-enforcement-actions-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"search":"Amazon","maxItems":25}'
```

### Use with MCP

You can use this actor from Claude Desktop, Claude Code, or any MCP client through Apify MCP.

MCP server URL:

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

Example prompts:

- "Run the FTC Enforcement Actions Scraper for Amazon and summarize pending matters."
- "Find FTC cases updated this month and export the dataset."
- "Collect detail links for FTC Kochava proceedings."

### Data freshness

The actor reads the live FTC public website at run time.

If the FTC updates a case page, a new actor run can capture the changed listing metadata.

### Reliability notes

The FTC listing is server-rendered HTML and does not require a browser for the core workflow.

The actor uses conservative HTTP requests and avoids unnecessary browser automation.

### Legality and responsible use

This actor extracts public information from FTC.gov.

You should use the data responsibly, respect Apify and FTC website terms, and avoid excessive run frequency.

The actor does not bypass authentication, paywalls, or private systems.

### FAQ and troubleshooting

#### Why did I get fewer records than `maxItems`?

Your filters may match fewer FTC records than the requested limit.

Try removing a filter or using a broader keyword.

#### Why are documents empty?

Documents are only collected when `includeDetails` is enabled and the FTC detail page exposes relevant links.

#### Why is the run slower with details enabled?

Detail mode opens every individual FTC case page, which adds one HTTP request per record.

### Related scrapers

Explore other Automation Lab actors for regulatory, legal, and public-record monitoring:

- https://apify.com/automation-lab/sec-litigation-releases-scraper
- https://apify.com/automation-lab/fda-warning-letters-scraper
- https://apify.com/automation-lab/courtlistener-federal-docket-scraper

### Changelog

#### 0.1

Initial version with FTC listing scraping, filters, pagination, optional detail enrichment, and pay-per-event output.

### Support

If you need a field from FTC detail pages that is not currently included, open an Apify issue with an example FTC URL and the expected field.

### Maintained source

This actor targets the official FTC Legal Library cases/proceedings pages.

### Output guarantees

Each record includes `title`, `detailUrl`, `sourceUrl`, and `scrapedAt` when the FTC listing card contains a valid case link.

Optional fields may be `null` or empty arrays when the FTC page does not expose that information.

### Performance guidance

Listing-only mode is best for broad scans.

Detail mode is best for smaller, high-value legal research jobs.

### Scheduling guidance

For monitoring workflows, schedule a daily run with a targeted keyword and moderate `maxItems`.

For quarterly research exports, run a broader query with a higher `maxItems` value.

# Actor input Schema

## `startUrls` (type: `array`):

FTC cases/proceedings listing URLs to scrape. Leave the prefilled URL for the main FTC enforcement actions listing.

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

Search by keyword, company name, individual name, or case number.

## `actionTypes` (type: `array`):

Optional FTC action type filters.

## `caseStatus` (type: `string`):

Optional case status filter.

## `matterNumber` (type: `string`):

Optional FTC matter/file number search.

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

Optional earliest Last Updated date in MM/DD/YYYY format.

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

Optional latest Last Updated date in MM/DD/YYYY format.

## `sortBy` (type: `string`):

FTC listing sort order.

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

Maximum FTC cases/proceedings to save.

## `includeDetails` (type: `boolean`):

Open each case detail page to extract extra topics, documents, and press release links. This is slower but richer.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.ftc.gov/legal-library/browse/cases-proceedings"
    }
  ],
  "search": "Amazon",
  "caseStatus": "All",
  "sortBy": "field_date",
  "maxItems": 20,
  "includeDetails": false
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "startUrls": [
        {
            "url": "https://www.ftc.gov/legal-library/browse/cases-proceedings"
        }
    ],
    "search": "Amazon",
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/ftc-enforcement-actions-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "startUrls": [{ "url": "https://www.ftc.gov/legal-library/browse/cases-proceedings" }],
    "search": "Amazon",
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/ftc-enforcement-actions-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "startUrls": [
    {
      "url": "https://www.ftc.gov/legal-library/browse/cases-proceedings"
    }
  ],
  "search": "Amazon",
  "maxItems": 20
}' |
apify call automation-lab/ftc-enforcement-actions-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "FTC Enforcement Actions Scraper",
        "description": "⚖️ Scrape FTC enforcement actions, cases, proceedings, matter numbers, statuses, summaries, updates, and detail links for compliance monitoring.",
        "version": "0.1",
        "x-build-id": "h9gAuB9SaCWbrbzY6"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~ftc-enforcement-actions-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-ftc-enforcement-actions-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/automation-lab~ftc-enforcement-actions-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-ftc-enforcement-actions-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/automation-lab~ftc-enforcement-actions-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-ftc-enforcement-actions-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "FTC cases/proceedings listing URLs to scrape. Leave the prefilled URL for the main FTC enforcement actions listing.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "search": {
                        "title": "Keyword or party search",
                        "type": "string",
                        "description": "Search by keyword, company name, individual name, or case number."
                    },
                    "actionTypes": {
                        "title": "Type of action",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Optional FTC action type filters.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "Federal",
                                "Administrative",
                                "ProcessEnforcement"
                            ],
                            "enumTitles": [
                                "Federal",
                                "Administrative",
                                "Process Enforcement"
                            ]
                        }
                    },
                    "caseStatus": {
                        "title": "Case status",
                        "enum": [
                            "All",
                            "pending",
                            "closed",
                            "under_order",
                            "on_appeal"
                        ],
                        "type": "string",
                        "description": "Optional case status filter.",
                        "default": "All"
                    },
                    "matterNumber": {
                        "title": "FTC Matter/File Number",
                        "type": "string",
                        "description": "Optional FTC matter/file number search."
                    },
                    "startDate": {
                        "title": "Start date",
                        "type": "string",
                        "description": "Optional earliest Last Updated date in MM/DD/YYYY format."
                    },
                    "endDate": {
                        "title": "End date",
                        "type": "string",
                        "description": "Optional latest Last Updated date in MM/DD/YYYY format."
                    },
                    "sortBy": {
                        "title": "Sort by",
                        "enum": [
                            "field_date",
                            "search_api_relevance"
                        ],
                        "type": "string",
                        "description": "FTC listing sort order.",
                        "default": "field_date"
                    },
                    "maxItems": {
                        "title": "Maximum records",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum FTC cases/proceedings to save.",
                        "default": 100
                    },
                    "includeDetails": {
                        "title": "Fetch detail pages",
                        "type": "boolean",
                        "description": "Open each case detail page to extract extra topics, documents, and press release links. This is slower but richer.",
                        "default": false
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
