# Federal Register Scraper — Notices, Rules & Regulations (`parseforge/federal-register-regulatory-notices-rules-scraper`) Actor

Collect U.S. Federal Register documents with 27+ fields. Filter notices, rules, proposed rules, and presidential documents by agency, keyword, and date range. Get citations, CFR references, comment deadlines, docket IDs, and PDF/HTML links.

- **URL**: https://apify.com/parseforge/federal-register-regulatory-notices-rules-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** News, Automation, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.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.
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

![ParseForge Banner](https://raw.githubusercontent.com/ParseForge/apify-assets/main/banner.jpg)

## 🚀 Federal Register Scraper — Notices, Rules & Regulations

Whether you're a compliance officer tracking regulatory changes, a government affairs professional monitoring agency actions, or a legal researcher analyzing federal policy, this actor makes it easy to collect structured data from the Federal Register at scale.

> **The Federal Register Scraper collects regulatory documents from the U.S. Federal Register, with 27+ structured fields per document, plus powerful filtering by type, agency, keyword, and date range.**

### ✨ What Does It Do

- 🛰️ **Document collection** — Collect notices, rules, proposed rules, and presidential documents with full metadata
- 👨‍🚀 **Agency filtering** — Focus on specific agencies (EPA, FDA, DOD, etc.) to track only what matters to you
- 🌌 **Keyword search** — Find documents containing specific terms in titles or body text
- 🛸 **Date range filtering** — Monitor new documents or pull historical archives within any date window
- 🚀 **Rich structured data** — Get citations, CFR references, comment deadlines, page counts, docket IDs, and direct PDF/HTML links
- 🛰️ **High-speed collection** — Collect thousands of documents per minute

### 🎬 Demo Video

_Coming soon_

### 🔧 Input

**Document Type** — Filter by document type: Notice, Rule, Proposed Rule, or Presidential Document. Leave empty for all types.

**Keyword Search** — Search for documents containing this keyword in the title or body.

**Agency IDs** — Comma-separated list of agency IDs to filter by (e.g., `"12,538"`). Find IDs at federalregister.gov/api/v1/agencies.

**Publication Date From** — Filter documents published on or after this date (`YYYY-MM-DD` format).

**Publication Date To** — Filter documents published on or before this date (`YYYY-MM-DD` format).

**Significant Documents Only** — If enabled, only return documents flagged as significant.

**Sort By** — Sort order: Newest First, Oldest First, or Relevance.

**`maxItems`** — Maximum number of documents to collect. Free users are limited to 10 items.

```json
{
  "documentType": "RULE",
  "keyword": "environmental protection",
  "dateFrom": "2026-01-01",
  "dateTo": "2026-03-31",
  "maxItems": 100,
  "sortBy": "newest"
}
````

### 📊 Output

| 🛰️ Field | 📝 Description |
|----------|----------------|
| `documentUrl` | Direct link to the document on federalregister.gov |
| `pdfUrl` | Direct PDF download link |
| `jsonUrl` | JSON endpoint for full document data |
| `bodyHtmlUrl` | Full HTML body URL |
| `commentUrl` | URL to submit public comments |
| `title` | Document title |
| `type` | Document type (Notice, Rule, Proposed Rule, Presidential Document) |
| `subtype` | Document subtype (Executive Order, Memorandum, etc.) |
| `documentNumber` | Unique document identifier |
| `citation` | Federal Register citation (e.g., "91 FR 16147") |
| `abstract` | Document summary/abstract |
| `action` | Agency action description |
| `agencyNames` | Issuing agency names |
| `agencies` | Full agency details (name, ID, URL, hierarchy) |
| `cfrReferences` | Code of Federal Regulations references |
| `docketIds` | Associated docket identifiers |
| `regulationIdNumbers` | Regulation ID numbers (RIN) |
| `topics` | Document topics/subjects |
| `significant` | Whether flagged as significant |
| `startPage` | Starting page in the Federal Register |
| `endPage` | Ending page |
| `pageLength` | Total number of pages |
| `dates` | Important dates text |
| `publicationDate` | Date published in the Federal Register |
| `signingDate` | Date the document was signed |
| `effectiveOn` | Date the rule becomes effective |
| `commentsCloseOn` | Public comment deadline |
| `scrapedAt` | Timestamp of data collection |

```json
{
  "documentUrl": "https://www.federalregister.gov/documents/2026/03/31/2026-06286/addressing-dei-discrimination-by-federal-contractors",
  "pdfUrl": "https://www.govinfo.gov/content/pkg/FR-2026-03-31/pdf/2026-06286.pdf",
  "commentUrl": null,
  "title": "Addressing DEI Discrimination by Federal Contractors",
  "type": "Presidential Document",
  "subtype": "Executive Order",
  "documentNumber": "2026-06286",
  "citation": "91 FR 16147",
  "agencyNames": "Executive Office of the President",
  "pageLength": 3,
  "publicationDate": "2026-03-31",
  "signingDate": "2026-03-26",
  "scrapedAt": "2026-03-31T23:55:50.904Z"
}
```

### 🚀 Why Choose the Federal Register Scraper?

| Feature | Our Actor | Alternative |
|---------|-----------|-------------|
| Output fields | 27+ structured fields | 8-12 basic fields |
| Document types | All 4 types + subtypes | Usually notices only |
| Agency filtering | By ID, any combination | Limited or none |
| Date range | Flexible `YYYY-MM-DD` ranges | Fixed windows |
| Speed | 10K+ documents per minute | Slow collection |
| Comment deadlines | ✅ Included | ❌ Missing |
| CFR references | ✅ Included | ❌ Missing |
| Docket IDs | ✅ Included | ❌ Missing |
| Pay-per-event | ✅ Supported | ❌ Not available |

### 🛰️ How to Use

1. **Sign Up** — [Create a free account with $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp) on the Apify platform.
2. **Configure** — Set your document type, keyword, agency, and date filters.
3. **Run It** — Click "Start" and get structured Federal Register data in seconds.

That's it. No coding, no setup needed.

### 🌌 Business Use Cases

- 🛰️ **Compliance Officer** — Monitor new rules and proposed rules from specific agencies (FDA, EPA, OSHA) to ensure your organization stays compliant before effective dates.
- 👨‍🚀 **Government Affairs Director** — Track presidential documents and significant rules to brief leadership on regulatory changes affecting your industry.
- 🚀 **Legal Researcher** — Search for documents by keyword and date range to build comprehensive regulatory histories for litigation or policy analysis.
- 🛸 **Policy Analyst** — Aggregate rule-making data across agencies to identify regulatory trends, comment periods, and enforcement patterns.
- 🌌 **Government Contractor** — Monitor notices and solicitations from defense and procurement agencies to identify business opportunities.
- 🛰️ **Lobbying Firm** — Track comment deadlines across multiple agencies to coordinate stakeholder responses to proposed rules.

### ❓ FAQ

- 🚀 **How many documents can I collect?** — The Federal Register contains millions of documents. Free users can collect up to 10 items per run; paid users can collect up to 1,000,000.
- 🚀 **How do I find agency IDs?** — Visit federalregister.gov/api/v1/agencies for a full list of agencies with their IDs. Common ones: EPA (145), FDA (221), DOD (103).
- 🚀 **What document types are available?** — Notice, Rule, Proposed Rule, and Presidential Document (includes Executive Orders, Memoranda, Proclamations).
- 🚀 **Does this include the full document text?** — The actor returns metadata and links. The `bodyHtmlUrl` field links to the full HTML content of each document.
- 🚀 **How current is the data?** — The Federal Register is updated daily on business days. You'll get the latest published documents.
- 🚀 **Can I filter by multiple agencies?** — Yes, pass comma-separated agency IDs (e.g., `"145,221"` for EPA and FDA).

### 🔗 Integrate Federal Register Scraper with any app

- [Zapier integration](https://docs.apify.com/platform/integrations/zapier) — Trigger workflows when new regulations are published
- [Make (Integromat)](https://docs.apify.com/platform/integrations/make) — Automate regulatory monitoring pipelines
- [API access](https://docs.apify.com/api/v2) — Build custom compliance dashboards with direct access
- [Webhooks](https://docs.apify.com/platform/integrations/webhooks) — Get instant notifications when runs complete
- [Google Sheets](https://docs.apify.com/platform/integrations/google-sheets) — Export regulatory data directly to spreadsheets

### 🛸 More ParseForge Actors

- [ClinicalTrials Scraper](https://apify.com/parseforge/clinicaltrials-scraper) — Collect clinical trial data from ClinicalTrials.gov
- [SEC Forms Scraper](https://apify.com/parseforge/sec-forms-scraper) — Collect SEC filings and financial data
- [Data.gov Scraper](https://apify.com/parseforge/data-gov-scraper) — Collect datasets from the US government data portal

Browse our complete collection at [ParseForge on Apify](https://apify.com/parseforge).

### 🚀 Ready to Start?

[Create a free account with $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp) and start collecting Federal Register data in minutes.

### 🆘 Need Help?

- 📖 Check the FAQ section above
- 📚 Visit [Apify documentation](https://docs.apify.com)
- 💬 [Contact ParseForge support](https://tally.so/r/parseforge-support)

### ⚠️ Disclaimer

> This Actor is an independent tool and is not affiliated with, endorsed by, or connected to the Federal Register, the U.S. Government Publishing Office, or any government agency. It accesses publicly available data.

# Actor input Schema

## `keyword` (type: `string`):

Search for documents containing this keyword in the title or body.

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000.

## `documentType` (type: `string`):

Filter by document type. Leave empty for all types.

## `agencyIds` (type: `string`):

Comma-separated list of agency IDs to filter by (e.g., '12,538'). Find IDs at federalregister.gov/api/v1/agencies.

## `dateFrom` (type: `string`):

Filter documents published on or after this date (YYYY-MM-DD format).

## `dateTo` (type: `string`):

Filter documents published on or before this date (YYYY-MM-DD format).

## `significant` (type: `boolean`):

If enabled, only return documents flagged as significant.

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

Sort order for results.

## Actor input object example

```json
{
  "maxItems": 10,
  "significant": false,
  "sortBy": "newest"
}
```

# 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 = {
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/federal-register-regulatory-notices-rules-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 = { "maxItems": 10 }

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Federal Register Scraper — Notices, Rules & Regulations",
        "description": "Collect U.S. Federal Register documents with 27+ fields. Filter notices, rules, proposed rules, and presidential documents by agency, keyword, and date range. Get citations, CFR references, comment deadlines, docket IDs, and PDF/HTML links.",
        "version": "1.0",
        "x-build-id": "QAyAdVMR5eofOYkGn"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~federal-register-regulatory-notices-rules-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-federal-register-regulatory-notices-rules-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/parseforge~federal-register-regulatory-notices-rules-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-federal-register-regulatory-notices-rules-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/parseforge~federal-register-regulatory-notices-rules-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-federal-register-regulatory-notices-rules-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": {
                    "keyword": {
                        "title": "Keyword Search",
                        "type": "string",
                        "description": "Search for documents containing this keyword in the title or body."
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000."
                    },
                    "documentType": {
                        "title": "Document Type",
                        "enum": [
                            "",
                            "NOTICE",
                            "RULE",
                            "PRORULE",
                            "PRESDOCU"
                        ],
                        "type": "string",
                        "description": "Filter by document type. Leave empty for all types."
                    },
                    "agencyIds": {
                        "title": "Agency IDs",
                        "type": "string",
                        "description": "Comma-separated list of agency IDs to filter by (e.g., '12,538'). Find IDs at federalregister.gov/api/v1/agencies."
                    },
                    "dateFrom": {
                        "title": "Publication Date From",
                        "type": "string",
                        "description": "Filter documents published on or after this date (YYYY-MM-DD format)."
                    },
                    "dateTo": {
                        "title": "Publication Date To",
                        "type": "string",
                        "description": "Filter documents published on or before this date (YYYY-MM-DD format)."
                    },
                    "significant": {
                        "title": "Significant Documents Only",
                        "type": "boolean",
                        "description": "If enabled, only return documents flagged as significant.",
                        "default": false
                    },
                    "sortBy": {
                        "title": "Sort By",
                        "enum": [
                            "newest",
                            "oldest",
                            "relevance"
                        ],
                        "type": "string",
                        "description": "Sort order for results.",
                        "default": "newest"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
