# Federal Register Deadline Monitor (`challenge_logic/federal-register-deadline-monitor`) Actor

Find open Federal Register comment deadlines and effective dates from the official Federal Register API.

- **URL**: https://apify.com/challenge\_logic/federal-register-deadline-monitor.md
- **Developed by:** [Paul P](https://apify.com/challenge_logic) (community)
- **Categories:** Developer tools, Automation, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 1,000 deadline rows

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## Federal Register Deadline Monitor

Find open Federal Register comment deadlines and effective dates in clean rows.

This Actor searches the official Federal Register API and returns deadline-focused data for compliance teams, policy researchers, legal research support, journalists, and AI-agent workflows. It is built for practical regulatory deadline monitoring: search by keyword, agency, document type, publication date, comment deadline, effective date, RIN, docket ID context, and CFR references.

It uses official public FederalRegister.gov API data. It does not require login, does not use proxies, does not scrape protected pages, and does not collect private or personal data.

### What You Get

Each saved row is one Federal Register document normalized around the date that matters:

- Federal Register comment deadline.
- Rule effective date.
- Days until the next deadline.
- Agency names and slugs.
- CFR references.
- Regulation ID numbers (RINs).
- Docket IDs.
- Official FederalRegister.gov HTML link.
- Official govinfo.gov PDF link when available.

Use this as a Federal Register API helper, regulatory deadline monitor, proposed rule comment deadline finder, EPA rule monitor, FDA notices tracker, or structured input for an AI agent.

FederalRegister.gov is an informational XML rendition of Federal Register documents. Always verify legal conclusions against the official PDF on govinfo.gov and consult qualified counsel when decisions matter.

### Copy-Paste Examples

#### EPA Upcoming Comment Deadlines

```json
{
  "query": "climate",
  "agencies": ["environmental-protection-agency"],
  "documentTypes": ["PRORULE", "NOTICE"],
  "includeCommentDeadlines": true,
  "includeEffectiveDates": false,
  "onlyWithDeadlines": true,
  "onlyUpcoming": true,
  "maxResults": 5,
  "maxPages": 2,
  "requestDelaySeconds": 0.25,
  "sort": "newest"
}
````

#### FDA Effective Dates

```json
{
  "query": "drug",
  "agencies": ["food-and-drug-administration"],
  "documentTypes": ["RULE", "NOTICE"],
  "includeCommentDeadlines": false,
  "includeEffectiveDates": true,
  "onlyWithDeadlines": true,
  "onlyUpcoming": true,
  "maxResults": 5,
  "maxPages": 2,
  "requestDelaySeconds": 0.25,
  "sort": "newest"
}
```

#### Broad Agency Monitoring

```json
{
  "query": "",
  "agencies": ["labor-department"],
  "documentTypes": ["PRORULE", "RULE", "NOTICE"],
  "includeCommentDeadlines": true,
  "includeEffectiveDates": true,
  "onlyWithDeadlines": true,
  "onlyUpcoming": true,
  "maxResults": 10,
  "maxPages": 3,
  "requestDelaySeconds": 0.25,
  "sort": "newest"
}
```

### Example Output

```json
{
  "document_number": "2026-13302",
  "title": "Integrated Low-Level Radioactive Waste Disposal",
  "type": "Proposed Rule",
  "agency_names": ["Nuclear Regulatory Commission"],
  "agency_slugs": ["nuclear-regulatory-commission"],
  "publication_date": "2026-07-01",
  "next_deadline_date": "2026-08-17",
  "next_deadline_type": "comment_close",
  "days_until_next_deadline": 43,
  "deadline_status": "upcoming",
  "deadline_types": ["comment_close"],
  "comments_close_on": "2026-08-17",
  "effective_on": null,
  "is_new": true,
  "significant": false,
  "citation": "91 FR 40290",
  "cfr_references": ["10 CFR 20", "10 CFR 61", "10 CFR 73", "10 CFR 150"],
  "regulation_id_numbers": ["3150-AI92"],
  "docket_ids": ["NRC-2011-0012, NRC-2015-0003, and NRC-2017-0081"],
  "html_url": "https://www.federalregister.gov/documents/2026/07/01/2026-13302/integrated-low-level-radioactive-waste-disposal",
  "pdf_url": "https://www.govinfo.gov/content/pkg/FR-2026-07-01/pdf/2026-13302.pdf",
  "source": "FederalRegister.gov API"
}
```

### Pricing

This Actor uses Apify pay-per-event pricing.

Configured price: **$1.50 per 1,000 saved deadline rows** (`$0.0015` per row).

No proxy cost is added. No external API subscription is required. Runs that return only a few rows should cost only fractions of a cent to a few cents, depending on the result count.

### FAQ

#### Does this require a Federal Register API key?

No. It uses the public FederalRegister.gov API and requires no upstream API key.

#### Does this scrape private or protected data?

No. It uses official public API responses only. It does not use proxies, browser automation, private data, logged-in data, or paywalled data.

#### Why did my run return zero rows?

The most common reason is that the filters are too narrow or there are no upcoming deadlines for the selected topic. Try increasing `maxPages`, clearing the `query`, broadening `documentTypes`, or turning off `onlyUpcoming`.

#### How does stateful monitoring work?

Set `stateKey` to a stable key such as `epa-climate-watch` and set `emitOnlyNew` to `true`. The Actor will remember previously emitted document numbers in the default key-value store and emit only new matching rows in later runs.

#### Can I use this as legal advice?

No. This is a research and automation tool. Verify important deadlines against the official PDF on govinfo.gov and consult qualified counsel when legal decisions matter.

### When Not To Use This

Do not use this Actor for:

- Legal advice or guaranteed compliance.
- Trading, investing, or speculation signals.
- Automated public comment submission.
- Spam outreach or lead generation.
- Replacing the official Federal Register, govinfo.gov, or qualified counsel.

### Local Run

```bash
python3 -m venv .venv
. .venv/bin/activate
pip install -r requirements.txt
PYTHONPATH=src python -m fedreg_deadline_monitor.cli --input examples/input.json --output storage/local-output.json --state-file storage/state.json
```

### Test

```bash
PYTHONPATH=src python -m unittest discover -s tests
```

### Apify Run

The Apify entrypoint is `main.py`. It reads Actor input with `Actor.get_input()`, writes rows with `Actor.push_data()`, and can optionally persist seen document numbers in the default key-value store when `stateKey` is provided.

### Ethical Use

Good uses:

- Compliance monitoring.
- Policy research.
- Legal research support.
- Journalism and public-interest monitoring.
- AI-agent data retrieval from official public data.

Avoid claims that this provides legal advice, guarantees compliance, or replaces the official Federal Register source documents.

# Actor input Schema

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

Keyword or phrase to search in Federal Register documents.

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

Optional FederalRegister.gov agency slugs, such as environmental-protection-agency or food-and-drug-administration.

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

Filter by Federal Register document category.

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

Only include documents published on or after this date, in YYYY-MM-DD format.

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

Only include documents published on or before this date, in YYYY-MM-DD format.

## `deadlineDateFrom` (type: `string`):

Only include rows with a comment/effective deadline on or after this date. Leave blank to use today when Only upcoming is enabled.

## `deadlineDateTo` (type: `string`):

Only include rows with a comment/effective deadline on or before this date.

## `includeCommentDeadlines` (type: `boolean`):

Include documents with public comment close dates.

## `includeEffectiveDates` (type: `boolean`):

Include documents with effective dates.

## `onlyWithDeadlines` (type: `boolean`):

Skip documents that have no selected deadline date.

## `onlyUpcoming` (type: `boolean`):

Skip documents whose selected deadline dates are all before today.

## `emitOnlyNew` (type: `boolean`):

If enabled, skip document numbers provided in seenDocumentNumbers or loaded from stateKey.

## `seenDocumentNumbers` (type: `array`):

Optional document numbers to treat as already seen.

## `stateKey` (type: `string`):

Optional Apify key-value store key for persisted seen document numbers.

## `sort` (type: `string`):

Federal Register API result order.

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

Maximum number of rows to save to the dataset.

## `maxPages` (type: `integer`):

Safety cap for Federal Register API pages fetched. Each page fetch is delayed politely.

## `requestDelaySeconds` (type: `number`):

Pause between API page requests.

## `today` (type: `string`):

Optional YYYY-MM-DD date for reproducible tests. Leave blank in normal runs.

## Actor input object example

```json
{
  "query": "climate",
  "agencies": [],
  "documentTypes": [
    "PRORULE",
    "RULE",
    "NOTICE"
  ],
  "includeCommentDeadlines": true,
  "includeEffectiveDates": true,
  "onlyWithDeadlines": true,
  "onlyUpcoming": true,
  "emitOnlyNew": false,
  "seenDocumentNumbers": [],
  "sort": "newest",
  "maxResults": 100,
  "maxPages": 10,
  "requestDelaySeconds": 0.25
}
```

# Actor output Schema

## `deadlineRows` (type: `string`):

Federal Register documents normalized around comment close dates, effective dates, days remaining, agencies, CFR references, RINs, docket IDs, and official source links.

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "query": "climate",
    "agencies": [],
    "documentTypes": [
        "PRORULE",
        "RULE",
        "NOTICE"
    ],
    "seenDocumentNumbers": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("challenge_logic/federal-register-deadline-monitor").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 = {
    "query": "climate",
    "agencies": [],
    "documentTypes": [
        "PRORULE",
        "RULE",
        "NOTICE",
    ],
    "seenDocumentNumbers": [],
}

# Run the Actor and wait for it to finish
run = client.actor("challenge_logic/federal-register-deadline-monitor").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 '{
  "query": "climate",
  "agencies": [],
  "documentTypes": [
    "PRORULE",
    "RULE",
    "NOTICE"
  ],
  "seenDocumentNumbers": []
}' |
apify call challenge_logic/federal-register-deadline-monitor --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Federal Register Deadline Monitor",
        "description": "Find open Federal Register comment deadlines and effective dates from the official Federal Register API.",
        "version": "0.1",
        "x-build-id": "uDLWLiQeK0EG1QtaB"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/challenge_logic~federal-register-deadline-monitor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-challenge_logic-federal-register-deadline-monitor",
                "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/challenge_logic~federal-register-deadline-monitor/runs": {
            "post": {
                "operationId": "runs-sync-challenge_logic-federal-register-deadline-monitor",
                "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/challenge_logic~federal-register-deadline-monitor/run-sync": {
            "post": {
                "operationId": "run-sync-challenge_logic-federal-register-deadline-monitor",
                "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": {
                    "query": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Keyword or phrase to search in Federal Register documents."
                    },
                    "agencies": {
                        "title": "Agency slugs",
                        "type": "array",
                        "description": "Optional FederalRegister.gov agency slugs, such as environmental-protection-agency or food-and-drug-administration.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "documentTypes": {
                        "title": "Document types",
                        "type": "array",
                        "description": "Filter by Federal Register document category.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "RULE",
                                "PRORULE",
                                "NOTICE",
                                "PRESDOCU"
                            ],
                            "enumTitles": [
                                "Rule",
                                "Proposed Rule",
                                "Notice",
                                "Presidential Document"
                            ]
                        }
                    },
                    "publicationDateFrom": {
                        "title": "Publication date from",
                        "type": "string",
                        "description": "Only include documents published on or after this date, in YYYY-MM-DD format."
                    },
                    "publicationDateTo": {
                        "title": "Publication date to",
                        "type": "string",
                        "description": "Only include documents published on or before this date, in YYYY-MM-DD format."
                    },
                    "deadlineDateFrom": {
                        "title": "Deadline date from",
                        "type": "string",
                        "description": "Only include rows with a comment/effective deadline on or after this date. Leave blank to use today when Only upcoming is enabled."
                    },
                    "deadlineDateTo": {
                        "title": "Deadline date to",
                        "type": "string",
                        "description": "Only include rows with a comment/effective deadline on or before this date."
                    },
                    "includeCommentDeadlines": {
                        "title": "Comment deadlines",
                        "type": "boolean",
                        "description": "Include documents with public comment close dates.",
                        "default": true
                    },
                    "includeEffectiveDates": {
                        "title": "Effective dates",
                        "type": "boolean",
                        "description": "Include documents with effective dates.",
                        "default": true
                    },
                    "onlyWithDeadlines": {
                        "title": "Only rows with deadlines",
                        "type": "boolean",
                        "description": "Skip documents that have no selected deadline date.",
                        "default": true
                    },
                    "onlyUpcoming": {
                        "title": "Only upcoming deadlines",
                        "type": "boolean",
                        "description": "Skip documents whose selected deadline dates are all before today.",
                        "default": true
                    },
                    "emitOnlyNew": {
                        "title": "Emit only new documents",
                        "type": "boolean",
                        "description": "If enabled, skip document numbers provided in seenDocumentNumbers or loaded from stateKey.",
                        "default": false
                    },
                    "seenDocumentNumbers": {
                        "title": "Already seen document numbers",
                        "type": "array",
                        "description": "Optional document numbers to treat as already seen.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "stateKey": {
                        "title": "State key",
                        "type": "string",
                        "description": "Optional Apify key-value store key for persisted seen document numbers."
                    },
                    "sort": {
                        "title": "Sort order",
                        "enum": [
                            "newest",
                            "oldest",
                            "relevance"
                        ],
                        "type": "string",
                        "description": "Federal Register API result order.",
                        "default": "newest"
                    },
                    "maxResults": {
                        "title": "Maximum saved rows",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of rows to save to the dataset.",
                        "default": 100
                    },
                    "maxPages": {
                        "title": "Maximum API pages",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Safety cap for Federal Register API pages fetched. Each page fetch is delayed politely.",
                        "default": 10
                    },
                    "requestDelaySeconds": {
                        "title": "Request delay seconds",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "number",
                        "description": "Pause between API page requests.",
                        "default": 0.25
                    },
                    "today": {
                        "title": "Today override",
                        "type": "string",
                        "description": "Optional YYYY-MM-DD date for reproducible tests. Leave blank in normal runs."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
