# Federal Register Documents Scraper (`compute-edge/federal-register-scraper`) Actor

Extract U.S. Federal Register documents via the public API. Filter by query, document types (rules, notices, proposed rules), publication date, and agencies. Includes full document details, citations, and regulatory information.

- **URL**: https://apify.com/compute-edge/federal-register-scraper.md
- **Developed by:** [Compute Edge](https://apify.com/compute-edge) (community)
- **Categories:** Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## Federal Register Documents Scraper

Extract U.S. Federal Register documents with advanced filtering. This Actor scrapes government regulations, notices, proposed rules, and official government documents from the Federal Register public API — the official U.S. government publication of regulatory actions, legal notices, and executive orders.

### Features

- **Public API Access** — No authentication required. Uses the official Federal Register API (no HTML scraping).
- **Full-Text Search** — Search all Federal Register documents by keywords (e.g., "renewable energy", "FDA approval", "climate").
- **Filter by Document Type** — Extract only specific document types: RULE, NOTICE, PROPOSED RULE, EXECUTIVE ORDER, etc.
- **Date Range Filtering** — Filter documents by publication date to track recent regulatory actions.
- **Agency Filtering** — Focus on specific federal agencies (e.g., Environmental Protection Agency, Food and Drug Administration).
- **Complete Document Data** — Extract document number, title, type, abstract, publication date, effective date, agency names, and URLs.
- **Pagination Support** — Automatically handles pagination to retrieve thousands of documents.
- **Batch Processing** — Efficient batch processing for large result sets.

### Data Fields

| Field | Type | Description |
|-------|------|-------------|
| `document_number` | string | Unique Federal Register document identifier (e.g., "2026-10039") |
| `title` | string | Official title of the document |
| `type` | string | Document type: RULE, NOTICE, PROPOSED RULE, etc. |
| `abstract` | string | Summary of the document's content (if available) |
| `publication_date` | date | Date the document was published in Federal Register (YYYY-MM-DD) |
| `effective_on` | date | Effective date of the rule or notice |
| `agencies` | string | Names of agencies involved (semicolon-separated) |
| `html_url` | url | Direct link to the full document on federalregister.gov |
| `pdf_url` | url | Direct link to PDF version on govinfo.gov |
| `citation` | string | Legal citation (e.g., "Federal Register: Vol 91, No. 100") |
| `page_length` | number | Number of pages in the document |

### Tutorial: How to Scrape Federal Register Documents

#### Step 1: Choose Your Search Strategy

The Actor supports multiple filtering options:

**Option A: Search by Keywords**
Use the "Search Query" field to find documents containing specific terms.
- **Example**: "renewable energy" to find documents about wind, solar, and clean energy regulations
- **Use case**: Monitor regulatory changes in your industry

**Option B: Filter by Document Type**
Specify which types of documents you need.
- **RULE** — Final federal regulations
- **NOTICE** — Notices, announcements, and public information
- **PROPOSED RULE** — Draft rules open for public comment
- **EXECUTIVE ORDER** — Presidential executive orders
- **Example**: Filter for "PROPOSED RULE" to catch upcoming regulatory changes before finalization

**Option C: Filter by Agency**
Focus on specific federal agencies.
- **environmental-protection-agency** — EPA regulations
- **food-and-drug-administration** — FDA decisions
- **department-of-labor** — Labor regulations
- **example-agency-slug** — Use the agency slug from federalregister.gov

**Option D: Filter by Date Range**
Track recent regulatory activity.
- **Example**: Set "Publication Date From" to "2026-01-01" to see regulations announced in 2026

#### Step 2: Configure the Actor

##### Minimal Setup (Retrieve Latest Documents)
1. Leave all fields blank or use defaults
2. Set "Max Results" to 200
3. Run the Actor
4. Result: ~200 of the latest Federal Register documents

##### Intermediate Setup (Monitor an Agency)
1. Set **Agencies** to `["food-and-drug-administration"]`
2. Set **Document Types** to `["RULE", "NOTICE"]`
3. Set **Max Results** to 500
4. Run the Actor
5. Result: Recent FDA rules and notices

##### Advanced Setup (Industry-Specific Research)
1. Set **Search Query** to `"medical devices"`
2. Set **Document Types** to `["PROPOSED RULE"]`
3. Set **Agencies** to `["food-and-drug-administration"]`
4. Set **Publication Date From** to `2025-01-01`
5. Set **Max Results** to 1000
6. Run the Actor
7. Result: Proposed FDA regulations for medical devices in 2025-2026

#### Step 3: Review and Download Results

After the Actor completes:

1. **View Results** — Browse the dataset in the "Results" tab
2. **Download as JSON** — Export all documents for analysis
3. **Download as CSV** — Spreadsheet format for Excel/Sheets
4. **Use via API** — Access results programmatically via Apify's dataset API

#### Example Searches

| Use Case | Query | Document Types | Agencies |
|----------|-------|-----------------|----------|
| **Renewable Energy** | "solar OR wind OR geothermal" | RULE, PROPOSED RULE | environmental-protection-agency, department-of-energy |
| **Healthcare Regulations** | "healthcare OR medical" | RULE, NOTICE | food-and-drug-administration, centers-for-medicare-medicaid-services |
| **Labor Standards** | "minimum wage OR overtime" | RULE, PROPOSED RULE | department-of-labor |
| **Environmental** | "emissions OR pollution OR water" | RULE | environmental-protection-agency |
| **Tax Changes** | "tax OR deduction" | NOTICE, RULE | internal-revenue-service |

### Input Parameters

```json
{
  "query": "renewable energy",
  "documentTypes": ["RULE", "PROPOSED RULE"],
  "publicationDateGte": "2025-01-01",
  "agencies": ["environmental-protection-agency"],
  "maxResults": 500
}
````

#### Parameter Descriptions

- **query** (optional, string): Free-text search across all Federal Register documents
- **documentTypes** (optional, array): Filter by document type. Leave empty to include all types
- **publicationDateGte** (optional, date): Only include documents published on or after this date (YYYY-MM-DD)
- **agencies** (optional, array): Filter by agency slugs from federalregister.gov
- **maxResults** (optional, integer): Maximum number of documents to fetch (default: 200, max: 10,000)

### Output Example

```json
[
  {
    "document_number": "2026-10039",
    "title": "Agency Forms Undergoing Paperwork Reduction Act Review",
    "type": "Notice",
    "abstract": "Public comment opportunity for federal agency forms under review.",
    "publication_date": "2026-05-20",
    "effective_on": "2026-06-15",
    "agencies": "Health and Human Services Department; Centers for Disease Control and Prevention",
    "html_url": "https://www.federalregister.gov/documents/2026/05/20/2026-10039/agency-forms-undergoing-paperwork-reduction-act-review",
    "pdf_url": "https://www.govinfo.gov/content/pkg/FR-2026-05-20/pdf/2026-10039.pdf",
    "citation": "Federal Register: Vol 91, No. 100",
    "page_length": 8
  },
  {
    "document_number": "2026-10087",
    "title": "Bulk Manufacturer of Controlled Substances Application",
    "type": "Notice",
    "abstract": "Application notice for bulk manufacturer registration.",
    "publication_date": "2026-05-20",
    "effective_on": "2026-07-01",
    "agencies": "Justice Department; Drug Enforcement Administration",
    "html_url": "https://www.federalregister.gov/documents/2026/05/20/2026-10087/bulk-manufacturer-of-controlled-substances-application-organix-chemistry-solutions-llc",
    "pdf_url": "https://www.govinfo.gov/content/pkg/FR-2026-05-20/pdf/2026-10087.pdf",
    "citation": "Federal Register: Vol 91, No. 100",
    "page_length": 12
  }
]
```

### Pricing

This Actor is priced per document extracted:

- **$0.002 per document** — Standard pricing for Federal Register documents
- **Minimum run cost** — ~$0.10-0.20 (typical run extracts 50-100 documents)
- **Example costs**:
  - 100 documents = $0.20
  - 500 documents = $1.00
  - 1,000 documents = $2.00

You also pay for Apify compute time. Most runs complete in 10-30 seconds with standard compute costs (~$0.10-0.30 per run).

### Common Use Cases

#### 1. **Regulatory Intelligence for Legal Teams**

Monitor upcoming federal rules that affect your clients. Filter by agency and document type to catch proposed rules before they're finalized.

#### 2. **Compliance Tracking**

Track effective dates of new regulations in your industry. Export dates and titles to share with compliance teams.

#### 3. **Industry Research**

Analyze regulatory trends in your vertical (healthcare, energy, finance, etc.). Search for keywords and download years of regulatory history.

#### 4. **Public Comment Preparation**

Find proposed rules related to your business and extract comment deadlines and implementation details.

#### 5. **Government Affairs Intelligence**

Track agency activity and regulatory workload. Monitor which agencies are most active in your sector.

### Limitations & Notes

- **API Source** — This Actor uses the official Federal Register API (no HTML scraping). All data is publicly accessible.
- **Search Scope** — Searches limited to Federal Register documents (does NOT include state regulations, local ordinances, or non-regulatory federal notices).
- **Response Time** — Typical runs complete in 10-60 seconds depending on result volume.
- **Data Freshness** — Federal Register updates daily; documents appear 1-2 days after official publication.

### API Features Not Included

This Actor focuses on core document extraction. The following advanced features are available via direct API but not exposed as inputs:

- Comment deadline filtering
- Sorting by relevance or date
- CFR/USC citation cross-references
- Executive order tracking

For these, query the Federal Register API directly at `https://www.federalregister.gov/api/v1/`.

### Troubleshooting

**Q: I got 0 results. Why?**

- Your search query might be too specific. Try removing filters.
- Check agency slugs — use exact slugs from federalregister.gov.
- The date range might exclude current documents. Try removing date filters.

**Q: Can I search state regulations?**

- No. This Actor only covers the U.S. Federal Register. State-level data requires separate sources.

**Q: How do I get agency slugs?**

- Browse https://www.federalregister.gov/agencies/ to see all agencies and their URL slugs.
- Examples: `environmental-protection-agency`, `food-and-drug-administration`, `department-of-labor`

**Q: Can I export to Excel?**

- Yes. Download as CSV from the results page, then open in Excel/Sheets.

**Q: How often should I run this?**

- The Federal Register updates daily. Run weekly or monthly for monitoring.

### Legal Disclaimer

This Actor accesses only publicly available data from the official Federal Register API. You are responsible for:

- Complying with the [Federal Register Terms of Use](https://www.federalregister.gov/terms-and-conditions)
- Understanding and following any regulations extracted (legal review recommended)
- Using data responsibly and in compliance with applicable laws

The Federal Register is a public resource; commercial use is permitted. This Actor is provided as-is for informational purposes.

### Support

If you encounter issues:

1. Check that your parameters are valid (especially agency slugs)
2. Verify your date format is YYYY-MM-DD
3. Try a simpler search to isolate the problem
4. Review the Actor run logs for error messages

For questions, contact the Actor developer via Apify's support system.

### See Also

- **CISA Known Exploited Vulnerabilities Scraper** — Monitor security vulnerabilities in federal systems
- **SEC Filings Scraper** — Extract corporate financial disclosures
- **FTC Actions Scraper** — Track FTC enforcement actions and consumer protection notices

***

**Actor Version**: 0.1\
**Last Updated**: May 2026\
**Data Source**: [Federal Register API](https://www.federalregister.gov/api/v1/)\
**Maintainer**: seatsignal

# Actor input Schema

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

Search term for Federal Register documents. Examples: 'environmental regulations', 'FDA approval', 'renewable energy'.

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

Filter by document type. Leave empty for all types. Examples: 'RULE', 'NOTICE', 'PROPOSED RULE', 'NOTICE OF PROPOSED RULEMAKING'.

## `publicationDateGte` (type: `string`):

Only include documents published on or after this date (YYYY-MM-DD format). Example: '2025-01-01'.

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

Filter by agency slugs. Leave empty for all agencies. Examples: 'environmental-protection-agency', 'food-and-drug-administration'.

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

Maximum number of documents to return. Set to 0 for unlimited.

## Actor input object example

```json
{
  "query": "",
  "documentTypes": [],
  "publicationDateGte": "",
  "agencies": [],
  "maxResults": 200
}
```

# Actor output Schema

## `dataset` (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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("compute-edge/federal-register-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("compute-edge/federal-register-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 '{}' |
apify call compute-edge/federal-register-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Federal Register Documents Scraper",
        "description": "Extract U.S. Federal Register documents via the public API. Filter by query, document types (rules, notices, proposed rules), publication date, and agencies. Includes full document details, citations, and regulatory information.",
        "version": "0.1",
        "x-build-id": "zJryWajwpGjaiB2j1"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/compute-edge~federal-register-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-compute-edge-federal-register-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/compute-edge~federal-register-scraper/runs": {
            "post": {
                "operationId": "runs-sync-compute-edge-federal-register-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/compute-edge~federal-register-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-compute-edge-federal-register-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": {
                    "query": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Search term for Federal Register documents. Examples: 'environmental regulations', 'FDA approval', 'renewable energy'.",
                        "default": ""
                    },
                    "documentTypes": {
                        "title": "Document Types",
                        "type": "array",
                        "description": "Filter by document type. Leave empty for all types. Examples: 'RULE', 'NOTICE', 'PROPOSED RULE', 'NOTICE OF PROPOSED RULEMAKING'.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "publicationDateGte": {
                        "title": "Publication Date From",
                        "type": "string",
                        "description": "Only include documents published on or after this date (YYYY-MM-DD format). Example: '2025-01-01'.",
                        "default": ""
                    },
                    "agencies": {
                        "title": "Agencies",
                        "type": "array",
                        "description": "Filter by agency slugs. Leave empty for all agencies. Examples: 'environmental-protection-agency', 'food-and-drug-administration'.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 0,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of documents to return. Set to 0 for unlimited.",
                        "default": 200
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
