# Federal Register Regulatory Notices Scraper (`automation-lab/federal-register-regulatory-notices-scraper`) Actor

Monitor Federal Register rules, notices, agencies, PDFs, comment deadlines, and regulatory metadata from the public API.

- **URL**: https://apify.com/automation-lab/federal-register-regulatory-notices-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Other
- **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

## Federal Register Regulatory Notices Scraper

Extract rules, proposed rules, notices, presidential documents, agency metadata, comment deadlines, PDF links, and structured regulatory summaries from the public FederalRegister.gov API.

This actor is built for compliance teams, policy analysts, legal teams, lobbyists, government affairs teams, civic-tech builders, and data teams that need repeatable Federal Register monitoring without writing custom API pagination code.

### What does Federal Register Regulatory Notices Scraper do?

It searches FederalRegister.gov documents and saves clean dataset rows.

It supports keyword search.

It supports agency filters.

It supports document type filters.

It supports publication date filters.

It supports comment deadline filters.

It returns official Federal Register HTML URLs.

It returns PDF URLs when available.

It returns public inspection PDF URLs when available.

It returns abstracts and search snippets.

It returns agencies as both names and structured metadata.

It can include the raw FederalRegister.gov API object for audit workflows.

### Who is it for?

Compliance teams can monitor new rules and notices that affect regulated operations.

Legal teams can track proposed rules and comment windows.

Government affairs teams can follow agency actions by topic.

Policy analysts can build datasets for regulation trend analysis.

Consultants can schedule searches for client-specific regulatory topics.

Researchers can export Federal Register metadata to spreadsheets, BI tools, or databases.

Developers can use the actor as a hosted Federal Register extractor with an API, schedules, webhooks, and MCP access.

### Why use this actor?

FederalRegister.gov already exposes a strong API, but production workflows still need pagination, normalization, schemas, scheduling, exports, and integration endpoints.

This actor wraps the public API in an Apify actor that is easy to run manually, schedule daily, call from code, connect to Make/Zapier, or query from Claude through MCP.

It is HTTP/API based, so it does not use a browser and does not require proxies for normal runs.

### What data can you extract?

| Field | Description |
| --- | --- |
| `title` | Federal Register document title |
| `documentType` | Rule, Proposed Rule, Notice, or Presidential Document |
| `abstract` | Official abstract when provided |
| `publicationDate` | Publication date in `YYYY-MM-DD` format |
| `agencyNames` | Display-friendly agency names |
| `agencies` | Structured agency metadata with slug, id, raw name, and URL |
| `documentNumber` | Federal Register document number |
| `citation` | Citation when returned by the API |
| `htmlUrl` | Official FederalRegister.gov document page |
| `pdfUrl` | GovInfo PDF URL when available |
| `publicInspectionPdfUrl` | Public inspection PDF URL when available |
| `commentUrl` | Comment submission URL when available |
| `commentsCloseOn` | Comment deadline when available |
| `excerpts` | Search snippets with matched terms |
| `sourceUrl` | Federal Register API URL used for the page |
| `raw` | Optional original API object |
| `scrapedAt` | Timestamp of extraction |

### How much does it cost to scrape Federal Register regulatory notices?

The actor uses pay-per-event pricing.

There is a small run start fee.

There is a per-document charge for each dataset item saved.

Use `maxItems` to control run size.

A small daily monitoring job for one agency and one topic can stay inexpensive.

Larger historical backfills cost more because they save more Federal Register documents.

### Input options

#### Search term

Use `term` for a keyword or phrase such as `cybersecurity`, `climate`, `bank capital`, or `medical device`.

#### Agencies

Use FederalRegister.gov agency slugs or IDs.

Examples:

- `environmental-protection-agency`
- `homeland-security-department`
- `securities-and-exchange-commission`
- `food-and-drug-administration`

#### Document types

Choose any combination of:

- `RULE` — final rules
- `PRORULE` — proposed rules
- `NOTICE` — notices
- `PRESDOCU` — presidential documents

#### Publication dates

Use `publicationDateFrom` and `publicationDateTo` in `YYYY-MM-DD` format.

#### Comment deadlines

Use `commentDateFrom` and `commentDateTo` to focus on open or upcoming comment windows.

#### Sort order

Use `relevance`, `newest`, or `oldest`.

#### Maximum documents

Use `maxItems` to limit the number of saved records.

#### Raw metadata

Set `includeRaw` to `true` when you need the full FederalRegister.gov API object for audits or custom downstream processing.

### Example input

```json
{
  "term": "cybersecurity",
  "agencies": ["homeland-security-department"],
  "documentTypes": ["RULE", "PRORULE", "NOTICE"],
  "publicationDateFrom": "2024-01-01",
  "sortBy": "newest",
  "maxItems": 100,
  "includeRaw": false
}
````

### Example output

```json
{
  "title": "Cybersecurity in the Marine Transportation System",
  "documentType": "Rule",
  "abstract": "The Coast Guard is updating its maritime security regulations...",
  "publicationDate": "2025-01-17",
  "agencyNames": ["Homeland Security Department", "Coast Guard"],
  "documentNumber": "2025-00708",
  "htmlUrl": "https://www.federalregister.gov/documents/...",
  "pdfUrl": "https://www.govinfo.gov/content/pkg/...pdf",
  "commentsCloseOn": null,
  "scrapedAt": "2026-06-30T00:00:00.000Z"
}
```

### How to run

1. Open the actor on Apify.

2. Enter a search term.

3. Optionally add agencies, document types, and date filters.

4. Set `maxItems`.

5. Run the actor.

6. Export the dataset as JSON, CSV, Excel, XML, RSS, or HTML.

### Scheduling ideas

Run daily for `cybersecurity` and DHS.

Run weekly for EPA proposed rules.

Run monthly for SEC notices.

Run ahead of compliance review meetings.

Run with comment deadline filters to monitor open consultation windows.

### Integration workflows

Send new records to Slack when a relevant proposed rule appears.

Append daily results to Google Sheets.

Store historical Federal Register data in BigQuery or Snowflake.

Trigger a webhook when a comment deadline is approaching.

Feed new regulatory notices into an internal compliance dashboard.

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/federal-register-regulatory-notices-scraper').call({
  term: 'cybersecurity',
  agencies: ['homeland-security-department'],
  documentTypes: ['RULE', 'PRORULE', 'NOTICE'],
  maxItems: 100,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('APIFY_TOKEN')
run = client.actor('automation-lab/federal-register-regulatory-notices-scraper').call(run_input={
    'term': 'cybersecurity',
    'agencies': ['homeland-security-department'],
    'documentTypes': ['RULE', 'PRORULE', 'NOTICE'],
    'maxItems': 100,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### API usage with cURL

```bash
curl "https://api.apify.com/v2/acts/automation-lab~federal-register-regulatory-notices-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"term":"cybersecurity","maxItems":100}'
```

### MCP access

Use the Apify MCP server to run this actor from Claude Desktop, Claude Code, or another MCP client.

MCP URL:

```text
https://mcp.apify.com/?tools=automation-lab/federal-register-regulatory-notices-scraper
```

Claude Code setup:

```bash
claude mcp add apify https://mcp.apify.com/?tools=automation-lab/federal-register-regulatory-notices-scraper
```

Claude Desktop JSON config:

```json
{
  "mcpServers": {
    "apify-federal-register": {
      "url": "https://mcp.apify.com/?tools=automation-lab/federal-register-regulatory-notices-scraper"
    }
  }
}
```

Example prompts:

- "Run the Federal Register scraper for EPA climate proposed rules from 2025."
- "Find DHS cybersecurity notices with comment deadlines."
- "Export the latest SEC notices about disclosure rules."

### Tips for better results

Use official agency slugs from FederalRegister.gov.

Keep `maxItems` small for monitoring runs.

Increase `maxItems` for historical backfills.

Use date filters to avoid mixing old and new documents.

Use `includeRaw` only when you need extra metadata.

Use schedules for recurring compliance monitoring.

### FAQ

#### Can I monitor one agency only?

Yes. Add FederalRegister.gov agency slugs or IDs in the `agencies` input.

#### Can I schedule daily regulatory alerts?

Yes. Use Apify schedules and webhooks to run the same search daily and send new results downstream.

### Troubleshooting

#### Why did I get zero results?

Your term, agency, type, or date filters may be too narrow. Remove one filter and try again.

#### Why are comment fields missing?

Not every Federal Register document has a comment URL or comment deadline.

#### Why are excerpts formatted with HTML?

FederalRegister.gov returns search snippets with matched terms wrapped in HTML. This helps downstream tools highlight matches.

### Legality and source terms

This actor uses public FederalRegister.gov endpoints.

It does not bypass login, paywalls, or access controls.

You are responsible for using exported data in compliance with applicable laws and your organization's policies.

### Related scrapers

Try other automation-lab actors for government, compliance, and public-record monitoring workflows:

- https://apify.com/automation-lab/website-contact-finder
- https://apify.com/automation-lab/google-news-scraper
- https://apify.com/automation-lab/rss-feed-scraper

### Changelog

Initial version: API-backed Federal Register document search with keyword, agency, type, date, comment-deadline, and raw metadata options.

### Support

If a Federal Register API change breaks extraction, open an issue on the actor page and include your input, run ID, and expected result.

# Actor input Schema

## `term` (type: `string`):

Keyword or phrase to search across Federal Register document text, titles, and metadata.

## `agencies` (type: `array`):

Optional FederalRegister.gov agency slugs or numeric IDs, such as epa, securities-and-exchange-commission, or 227.

## `documentTypes` (type: `array`):

Filter to Presidential documents, rules, proposed rules, and notices.

## `publicationDateFrom` (type: `string`):

Only include documents published on or after this date (YYYY-MM-DD).

## `publicationDateTo` (type: `string`):

Only include documents published on or before this date (YYYY-MM-DD).

## `commentDateFrom` (type: `string`):

Only include documents with comment deadlines on or after this date (YYYY-MM-DD), when available.

## `commentDateTo` (type: `string`):

Only include documents with comment deadlines on or before this date (YYYY-MM-DD), when available.

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

Federal Register sort order.

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

Maximum Federal Register documents to save to the dataset.

## `includeRaw` (type: `boolean`):

Adds the original FederalRegister.gov API object to each dataset item for audit/debug workflows.

## Actor input object example

```json
{
  "term": "cybersecurity",
  "agencies": [
    "homeland-security-department"
  ],
  "documentTypes": [
    "RULE",
    "PRORULE",
    "NOTICE"
  ],
  "publicationDateFrom": "2025-01-01",
  "sortBy": "newest",
  "maxItems": 20,
  "includeRaw": 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 = {
    "term": "cybersecurity",
    "agencies": [
        "homeland-security-department"
    ],
    "documentTypes": [
        "RULE",
        "PRORULE",
        "NOTICE"
    ],
    "publicationDateFrom": "2025-01-01",
    "sortBy": "newest",
    "maxItems": 20,
    "includeRaw": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/federal-register-regulatory-notices-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 = {
    "term": "cybersecurity",
    "agencies": ["homeland-security-department"],
    "documentTypes": [
        "RULE",
        "PRORULE",
        "NOTICE",
    ],
    "publicationDateFrom": "2025-01-01",
    "sortBy": "newest",
    "maxItems": 20,
    "includeRaw": False,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/federal-register-regulatory-notices-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 '{
  "term": "cybersecurity",
  "agencies": [
    "homeland-security-department"
  ],
  "documentTypes": [
    "RULE",
    "PRORULE",
    "NOTICE"
  ],
  "publicationDateFrom": "2025-01-01",
  "sortBy": "newest",
  "maxItems": 20,
  "includeRaw": false
}' |
apify call automation-lab/federal-register-regulatory-notices-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Federal Register Regulatory Notices Scraper",
        "description": "Monitor Federal Register rules, notices, agencies, PDFs, comment deadlines, and regulatory metadata from the public API.",
        "version": "0.1",
        "x-build-id": "EA9G6Cmhs9RRZQeRn"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~federal-register-regulatory-notices-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-federal-register-regulatory-notices-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~federal-register-regulatory-notices-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-federal-register-regulatory-notices-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~federal-register-regulatory-notices-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-federal-register-regulatory-notices-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": {
                    "term": {
                        "title": "🔎 Search term",
                        "type": "string",
                        "description": "Keyword or phrase to search across Federal Register document text, titles, and metadata."
                    },
                    "agencies": {
                        "title": "🏛️ Agency slugs or IDs",
                        "type": "array",
                        "description": "Optional FederalRegister.gov agency slugs or numeric IDs, such as epa, securities-and-exchange-commission, or 227.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "documentTypes": {
                        "title": "📄 Document types",
                        "type": "array",
                        "description": "Filter to Presidential documents, rules, proposed rules, and notices.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "PRESDOCU",
                                "RULE",
                                "PRORULE",
                                "NOTICE"
                            ],
                            "enumTitles": [
                                "Presidential Document",
                                "Rule",
                                "Proposed Rule",
                                "Notice"
                            ]
                        }
                    },
                    "publicationDateFrom": {
                        "title": "Publication date from",
                        "type": "string",
                        "description": "Only include documents published on or after this date (YYYY-MM-DD)."
                    },
                    "publicationDateTo": {
                        "title": "Publication date to",
                        "type": "string",
                        "description": "Only include documents published on or before this date (YYYY-MM-DD)."
                    },
                    "commentDateFrom": {
                        "title": "Comment deadline from",
                        "type": "string",
                        "description": "Only include documents with comment deadlines on or after this date (YYYY-MM-DD), when available."
                    },
                    "commentDateTo": {
                        "title": "Comment deadline to",
                        "type": "string",
                        "description": "Only include documents with comment deadlines on or before this date (YYYY-MM-DD), when available."
                    },
                    "sortBy": {
                        "title": "Sort by",
                        "enum": [
                            "relevance",
                            "newest",
                            "oldest"
                        ],
                        "type": "string",
                        "description": "Federal Register sort order.",
                        "default": "relevance"
                    },
                    "maxItems": {
                        "title": "Maximum documents",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum Federal Register documents to save to the dataset.",
                        "default": 20
                    },
                    "includeRaw": {
                        "title": "Include raw API metadata",
                        "type": "boolean",
                        "description": "Adds the original FederalRegister.gov API object to each dataset item for audit/debug workflows.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
