# Grants.gov Scraper - Federal Grants + Award Detail (`maydit/us-federal-grants-scraper`) Actor

Scrape Grants.gov for federal grant opportunities with full award detail: ceiling/floor, deadlines, eligibility, cost-sharing, ALN, and named agency contact. Export to CSV/Excel/JSON.

- **URL**: https://apify.com/maydit/us-federal-grants-scraper.md
- **Developed by:** [Brandt May](https://apify.com/maydit) (community)
- **Categories:** Business, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 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.

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

## Grants.gov Scraper - Federal Grant Opportunities with Full Award Detail

> The only Grants.gov scraper that returns apply-ready award detail per opportunity - ceiling, floor, eligibility, cost-sharing, and a named agency contact - not just title, agency, and deadline.

### What it does

This **Grants.gov scraper** searches the official Grants.gov database and returns fully enriched **federal grant opportunities data** - not the thin title/agency/deadline listings most competitors export. For each opportunity it fetches the full detail record, so you get the award ceiling and floor, estimated total program funding, expected number of awards, open and close dates, applicant eligibility, cost-sharing requirements, ALN/CFDA references, and a named agency contact with email and phone. Filter by keyword, status, agency, funding category, eligibility, or ALN, then export the whole dataset to CSV, Excel, or JSON. It works like a **Grants.gov API** with no key required.

### Who it's for

- **Grant writers and grant consultants** building apply-ready prospect lists
- **Nonprofits** searching for grants they are eligible for
- **Universities and research offices** tracking agency and program funding
- **Small businesses** monitoring SBIR/STTR and forecasted opportunities
- **Developers and data teams** who want a clean federal funding opportunities dataset without touching a raw HTML feed

### What you get / Output

Every opportunity is returned as a structured record. When **Include full award details** is on (default), each record is enriched with the full detail fields below.

| Field | Description |
|---|---|
| `opportunityId` | Internal Grants.gov opportunity ID |
| `opportunityNumber` | Public funding opportunity number (FON) |
| `title` | Cleaned opportunity title |
| `agency` | Funding agency / subagency |
| `status` | Posted, forecasted, closed, or archived |
| `docType` | Opportunity document type |
| `openDate` | Application open date |
| `closeDate` | Application close / deadline date |
| `alns` | Assistance Listing Numbers (formerly CFDA) |
| `description` | Cleaned opportunity description text |
| `awardCeiling` | Maximum per-award amount |
| `awardFloor` | Minimum per-award amount |
| `estimatedTotalFunding` | Estimated total program funding |
| `expectedAwards` | Expected number of awards |
| `costSharing` | Cost-sharing / matching requirement |
| `applicantTypes` | Eligible applicant types |
| `applicantEligibility` | Eligibility notes |
| `fundingInstruments` | Grant, cooperative agreement, etc. |
| `fundingCategories` | Program category codes |
| `agencyContact` | Contact `name`, `email`, and `phone` |
| `estimatedAwardDate` | Estimated award date |
| `url` | Official Grants.gov opportunity URL |

### Input / How to query

| Input | What it does |
|---|---|
| `keyword` | Full-text search, e.g. `solar`, `rural health`, `small business innovation`. Leave empty for all. |
| `oppStatuses` | One or more of `posted` (open now), `forecasted` (upcoming), `closed`, `archived`. Defaults to `posted`. |
| `agencies` | Exact Grants.gov agency/subagency codes, e.g. `NSF`, `HHS-NIH11`, `DOD-AFOSR`. Department-level codes like `USDA` alone will not match - use the specific subagency code. |
| `fundingCategories` | Category codes, e.g. `EN` (Energy), `AG` (Agriculture), `HL` (Health), `ED` (Education), `ST` (Science & Technology), `BC` (Business & Commerce). |
| `eligibilities` | Applicant eligibility codes, e.g. `13` (Small businesses), `20` (Private higher ed), `00` (State governments), `99` (Unrestricted). |
| `aln` | Filter by a single Assistance Listing Number / CFDA, e.g. `47.050`. |
| `includeDetails` | Fetch the full award detail record per grant (award ceiling/floor, funding, deadlines, eligibility, agency contact). On by default; adds ~0.3s per grant. |
| `maxResults` | Upper bound on grants returned per run. Defaults to 500. |

**Two modes:** run a fast **search** (set `includeDetails` off for a lightweight listing) or a **full detail enrichment** pass (default) that returns the complete, apply-ready record for every matching opportunity.

### Example use cases

- **Grant writer prospect list:** search `keyword=workforce development`, `oppStatuses=[posted, forecasted]`, keep only opportunities where `awardCeiling` and `applicantTypes` fit the client, and export to Excel with the agency contact for outreach.
- **Nonprofit eligibility check:** filter `eligibilities=[12]` (nonprofits without 501c3) plus a mission keyword to surface only grants your org can actually apply for.
- **University research office pipeline:** pull all `posted` and `forecasted` opportunities for target `agencies` (e.g. `NSF`, `HHS-NIH11`) into a shared sheet, sorted by `closeDate`.
- **Small business SBIR/STTR tracker:** search `keyword=SBIR`, `eligibilities=[13]`, and monitor forecasted opportunities to get ahead of deadlines.
- **ALN/CFDA program monitoring:** set `aln=47.050` to watch every opportunity under a specific assistance listing programmatically.

### Recurring use / scheduling

Use **Apify Schedules** to run this actor daily or weekly and keep a live view of federal funding. Because every record carries a stable `opportunityId` and `opportunityNumber`, you can dedupe against previous runs to detect only newly posted or newly forecasted opportunities - the basis for NOFO alerts and an automated grant deadline tracker. Point the scheduled run at a target `keyword`, `agencies`, or `fundingCategories` set, then wire the dataset into a webhook, Google Sheet, or email/Slack notification so new matches reach your grant team automatically.

### How do I scrape grant opportunities from Grants.gov?

Set your filters (keyword, status, agency, funding category, eligibility, or ALN), run the actor, and it queries the official Grants.gov database and returns structured records. Enable **Include full award details** for the complete, apply-ready dataset.

### Is there a Grants.gov API and does it need a key?

This actor works like a Grants.gov API and needs **no API key**. It reads the public Grants.gov data and returns clean, structured JSON you can call on a schedule or from your own code via the Apify API.

### How can I export all federal grant opportunities to CSV or Excel?

Run the actor, then download the resulting dataset in CSV, Excel, JSON, or HTML from the Apify run page or via the API. Use `maxResults` (default 500) to control how many opportunities each run returns.

### How do I get grant award ceiling, floor, and deadline data in bulk?

Keep `includeDetails` on (the default). Every record then includes `awardCeiling`, `awardFloor`, `estimatedTotalFunding`, `expectedAwards`, `openDate`, `closeDate`, and `estimatedAwardDate`.

### How can I monitor Grants.gov for new grant opportunities by agency or keyword?

Schedule a recurring run with your chosen `keyword` and `agencies` (or `fundingCategories`) filters, then dedupe on `opportunityId` between runs to surface only new opportunities - an automated Grants.gov monitor / NOFO alert.

### How do I find federal grants my nonprofit or small business is eligible for?

Filter by `eligibilities` (e.g. `13` for small businesses, `12` for nonprofits without 501c3, `20` for private higher ed) alongside a mission keyword, and check the `applicantTypes` and `applicantEligibility` fields on each result.

### How do I get agency contact info for a federal grant opportunity?

With full details enabled, each opportunity includes `agencyContact` with the contact `name`, `email`, and `phone` from the official listing.

### How can I search grants by ALN / CFDA number programmatically?

Set the `aln` input to an Assistance Listing Number (formerly CFDA), e.g. `47.050`. Every result also returns its `alns` for downstream filtering.

### What's the best way to track NOFO deadlines automatically?

Schedule the actor, capture `closeDate` and `estimatedAwardDate` per opportunity, dedupe on `opportunityNumber`, and route new or soon-to-close opportunities to your calendar, sheet, or notifications.

### How do I pull SBIR/STTR and forecasted grant opportunities into a spreadsheet?

Search `keyword=SBIR` (or `STTR`) with `oppStatuses=[posted, forecasted]` and `eligibilities=[13]`, then export the dataset to Excel or CSV.

### Data source & notes

- **Source:** the official **Grants.gov** public search and opportunity-detail data (the U.S. federal grants portal). No login or API key required.
- **Legal:** Grants.gov opportunity data is public U.S. government information intended for applicants and the public.
- **Notes:** Agency filters require exact Grants.gov subagency codes - department-level codes such as `USDA` alone will not match. Full detail enrichment adds roughly 0.3s per grant; disable `includeDetails` for a faster, lighter listing. Fields are populated only when the source opportunity provides them, so some optional values may be empty for a given grant.

# Actor input Schema

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

Full-text search across grant opportunities, e.g. 'solar', 'small business innovation', 'rural health'. Leave empty for all.
## `oppStatuses` (type: `array`):

Posted = open now. Forecasted = expected soon (great for getting ahead of deadlines).
## `agencies` (type: `array`):

Exact Grants.gov agency codes, e.g. 'NSF', 'USDA-RBCS', 'HHS-NIH11', 'DOD-AFOSR'. NOTE: department-level codes like 'USDA' alone will NOT match — use the specific subagency code (find them on grants.gov search filters). Leave empty for all.
## `fundingCategories` (type: `array`):

Category codes, e.g. 'EN' (Energy), 'AG' (Agriculture), 'HL' (Health), 'ED' (Education), 'ST' (Science & Technology), 'BC' (Business & Commerce). Leave empty for all.
## `eligibilities` (type: `array`):

Applicant eligibility codes, e.g. '25' (Others), '99' (Unrestricted), '00' (State governments), '13' (Small businesses), '20' (Private institutions of higher education), '12' (Nonprofits w/o 501c3). Leave empty for all.
## `aln` (type: `string`):

Filter by Assistance Listing Number (formerly CFDA), e.g. '47.050'. Leave empty for all.
## `includeDetails` (type: `boolean`):

Fetch each grant's full detail record: award ceiling/floor, total program funding, expected number of awards, applicant types & eligibility, deadlines, and agency contact. Adds ~0.3s per grant.
## `maxResults` (type: `integer`):

Upper bound on grants returned per run.

## Actor input object example

```json
{
  "keyword": "clean energy",
  "oppStatuses": [
    "posted"
  ],
  "agencies": [],
  "fundingCategories": [],
  "eligibilities": [],
  "includeDetails": true,
  "maxResults": 500
}
````

# 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("maydit/us-federal-grants-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("maydit/us-federal-grants-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 maydit/us-federal-grants-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Grants.gov Scraper - Federal Grants + Award Detail",
        "description": "Scrape Grants.gov for federal grant opportunities with full award detail: ceiling/floor, deadlines, eligibility, cost-sharing, ALN, and named agency contact. Export to CSV/Excel/JSON.",
        "version": "1.0",
        "x-build-id": "yYnLnRwU0kWzmZzHD"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/maydit~us-federal-grants-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-maydit-us-federal-grants-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/maydit~us-federal-grants-scraper/runs": {
            "post": {
                "operationId": "runs-sync-maydit-us-federal-grants-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/maydit~us-federal-grants-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-maydit-us-federal-grants-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",
                        "type": "string",
                        "description": "Full-text search across grant opportunities, e.g. 'solar', 'small business innovation', 'rural health'. Leave empty for all."
                    },
                    "oppStatuses": {
                        "title": "Opportunity status",
                        "type": "array",
                        "description": "Posted = open now. Forecasted = expected soon (great for getting ahead of deadlines).",
                        "items": {
                            "type": "string",
                            "enum": [
                                "posted",
                                "forecasted",
                                "closed",
                                "archived"
                            ],
                            "enumTitles": [
                                "Posted (open)",
                                "Forecasted (upcoming)",
                                "Closed",
                                "Archived"
                            ]
                        },
                        "default": [
                            "posted"
                        ]
                    },
                    "agencies": {
                        "title": "Agency codes",
                        "type": "array",
                        "description": "Exact Grants.gov agency codes, e.g. 'NSF', 'USDA-RBCS', 'HHS-NIH11', 'DOD-AFOSR'. NOTE: department-level codes like 'USDA' alone will NOT match — use the specific subagency code (find them on grants.gov search filters). Leave empty for all.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "fundingCategories": {
                        "title": "Funding category codes",
                        "type": "array",
                        "description": "Category codes, e.g. 'EN' (Energy), 'AG' (Agriculture), 'HL' (Health), 'ED' (Education), 'ST' (Science & Technology), 'BC' (Business & Commerce). Leave empty for all.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "eligibilities": {
                        "title": "Eligibility codes",
                        "type": "array",
                        "description": "Applicant eligibility codes, e.g. '25' (Others), '99' (Unrestricted), '00' (State governments), '13' (Small businesses), '20' (Private institutions of higher education), '12' (Nonprofits w/o 501c3). Leave empty for all.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "aln": {
                        "title": "ALN / CFDA number",
                        "type": "string",
                        "description": "Filter by Assistance Listing Number (formerly CFDA), e.g. '47.050'. Leave empty for all."
                    },
                    "includeDetails": {
                        "title": "Include full award details",
                        "type": "boolean",
                        "description": "Fetch each grant's full detail record: award ceiling/floor, total program funding, expected number of awards, applicant types & eligibility, deadlines, and agency contact. Adds ~0.3s per grant.",
                        "default": true
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Upper bound on grants returned per run.",
                        "default": 500
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
