# FCC License Search (`maximedupre/fcc-license-search-scraper`) Actor

Search public FCC license records by call sign, licensee, location, service, status, or frequency. Export structured license details or look up U.S. census geography from coordinates.

- **URL**: https://apify.com/maximedupre/fcc-license-search-scraper.md
- **Developed by:** [Maxime Dupré](https://apify.com/maximedupre) (community)
- **Categories:** Business, Lead generation, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$1.80 / 1,000 fcc record returneds

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

### 📡 Turn public FCC license data into usable rows

Built for spectrum analysts, telecom teams, regulatory researchers, and sales operations, **FCC License Search** returns structured current licenses, recent ULS activity, or census geography for U.S. coordinates. Filter official identifiers, holders, locations, services, statuses, frequencies, and dates without supplying FCC credentials, then use the source links to review the public FCC pages.

- **FCC license lookup** — review the holder, status, dates, service, and frequencies for a known license.
- **FCC ULS search** — find current licenses by licensee, location, radio service, class, or status.
- **FCC call sign search** — match a complete call sign or search by partial text.
- **FCC frequency search** — find licenses within an inclusive MHz range or at one exact frequency.
- **FCC licensee search** — research licenses associated with a public organization or applicant name.
- **FCC license activity tracker** — collect recent grants, renewals, modifications, cancellations, or terminations.
- **FCC census block lookup** — resolve labeled coordinates to available block, tract, county, and state geography.

#### 📋 What data is returned?

Every successful row has a `resultType`:

- **`license`** — FCC unique system identifier, ULS file number, call sign, licensee or applicant, FRN, radio service, class, status, relevant dates, public address, frequencies, and FCC source URL when available.
- **`activity`** — event type and date plus available license identifier, file number, call sign, licensee, FRN, service, class, status, dates, location, frequencies, and source URL.
- **`coordinate`** — submitted label and coordinates plus available census block, tract, county, state, FIPS values, and FCC reference URL.

Optional properties are omitted when the public source does not provide them. Invalid inputs, failed lookups, and searches with no matches do not create dataset rows.

#### 🚀 How to run the Actor

1. Choose **License search**, **Recent licensing activity**, or **Coordinate lookup** under `target`.
2. Complete the options for that Target.
3. Set the corresponding maximum to control output volume.
4. Run the Actor and open the default dataset.
5. Export the rows or retrieve them through the Apify API.

A run handles one configured license search, one recent-activity query, or one list of coordinates. License and activity searches can return up to 2,000 successful rows; coordinate lookup accepts up to 500 entries.

#### 🎛️ Input

| Field | Target | Description |
| --- | --- | --- |
| `target` | All | Required: `licenses`, `activity`, or `coordinates`. |
| `callSign`, `licenseeName` | Licenses | Call sign or public holder/applicant name; `matchType` controls partial or exact matching. |
| `city`, `state`, `zipCode` | Licenses | Public location filters; `state` uses a two-letter U.S. state or territory code. |
| `radioServiceCode`, `licenseClass` | Licenses | FCC radio service or license class code or name. |
| `licenseStatus` | Licenses | Active (`A`), canceled (`C`), expired (`E`), or terminated (`T`). |
| `frequencyFromMhz`, `frequencyToMhz` | Licenses | Inclusive range; both are required, and equal values select one frequency. |
| `maxItems` | Licenses | Maximum successful, deduplicated licenses, from 1 to 2,000. |
| `lookbackDays` | Activity | Look back 1 to 365 days from the run date. |
| `eventType` | Activity | FCC event type or code; leave empty to include every event type in the period. |
| `activityMaxItems` | Activity | Maximum successful, deduplicated activity rows, from 1 to 2,000. |
| `coordinates` | Coordinates | Up to 500 `latitude, longitude` strings, optionally prefixed with `Label |`. |

A license search requires at least one criterion. Options belonging to inactive Targets are ignored.

```json
{
  "target": "activity",
  "lookbackDays": 30,
  "eventType": "new",
  "activityMaxItems": 100
}
````

#### 📤 Output

Results are written to the default Apify dataset. Use the overview for quick review or export through the dataset interface and API.

```json
{
  "resultType": "activity",
  "eventType": "new",
  "eventDate": "2026-07-10",
  "uniqueSystemIdentifier": "1234567",
  "callSign": "W1AW",
  "licenseeName": "Example Radio Club",
  "radioServiceCode": "HA",
  "licenseStatus": "A",
  "frequenciesMhz": [14.25],
  "sourceUrl": "https://wireless2.fcc.gov/UlsApp/UlsSearch/license.jsp?licKey=1234567"
}
```

#### 💳 Pricing

This Actor uses pay-per-event pricing. You are charged for each successful visible FCC license, licensing-activity, or coordinate-geography row returned. Empty searches, invalid coordinate entries, failed lookups, and operational messages are not charged as returned rows. Apify platform usage may also apply. If the run reaches your charge limit, rows already returned remain available and the Actor stops adding more.

#### 🔌 Integrations

Export the default dataset in Apify-supported formats, retrieve rows through the Apify API, start repeat runs with schedules, or trigger workflows with webhooks. These options support spreadsheet, database, dashboard, and application workflows without changing the row schema.

#### ❓ FAQ

##### Can I search one exact frequency?

Yes. Enter the same value for `frequencyFromMhz` and `frequencyToMhz`; both bounds are inclusive.

##### How is recent licensing activity selected?

Choose the `activity` Target, set `lookbackDays`, and optionally provide `eventType`. The Actor returns public ULS entries whose reported action date falls within that period and classifies available events as new, renewal, modification, cancellation, or termination.

##### What happens when one coordinate is malformed or cannot be resolved?

It produces no dataset row. The Actor continues with the remaining coordinates, so other valid entries can still return data.

##### Why are some properties absent?

FCC public data does not always contain every optional value. The Actor keeps a successful row and omits unavailable properties rather than filling them with guesses.

##### Can I submit several separately filtered searches in one run?

No. Configure separate runs for separate license or activity queries. Coordinate lookup accepts a simple list of up to 500 coordinates.

##### Does coordinate lookup find nearby transmitters or model coverage?

No. It resolves a point to available census geography. It does not search nearby licenses or calculate propagation, interference, coverage, or spectrum availability.

##### Does this Actor file, renew, or modify licenses?

No. It reads public FCC data and does not perform authenticated FCC account workflows or alter FCC records.

##### How does this differ from building directly on FCC ULS data?

The Actor applies the supported filters, normalizes successful entries into a documented Apify dataset, and retains public FCC links for follow-up. Direct source work may be preferable when you need a complete archive mirror, unsupported FCC datasets, or custom parsing beyond this Actor's schema.

### 📝 Changelog

- 0.1: Initial release.

### 🆘 Support

For issues, questions, or feature requests, [open an Actor issue](https://console.apify.com/actors/maximedupre~fcc-license-search-scraper/issues).

### 🔗 Related actors

- [U.S. Census Geocoder](https://apify.com/maximedupre/us-census-geocoder) — match U.S. addresses or coordinates to standardized addresses, TIGER/Line details, and optional Census geography identifiers.

**Made with ❤️ by Maxime Dupré**

# Actor input Schema

## `target` (type: `string`):

Choose the FCC public-record result family to collect.

## `callSign` (type: `string`):

FCC call sign, for example W1AW or KQED.

## `licenseeName` (type: `string`):

License holder, organization, or applicant name, for example Verizon or KQED Inc.

## `matchType` (type: `string`):

Apply partial or exact matching to the call sign and licensee or applicant name.

## `city` (type: `string`):

License or applicant location city, for example San Francisco.

## `state` (type: `string`):

Two-letter U.S. state or territory code, for example CA, TX, or PR.

## `zipCode` (type: `string`):

Five-digit U.S. ZIP code or ZIP+4, for example 94105 or 94105-1234.

## `radioServiceCode` (type: `string`):

FCC radio service code or name, such as AM, FM, HA, microwave, paging, cellular, aviation, or marine.

## `licenseClass` (type: `string`):

FCC license class code or name.

## `licenseStatus` (type: `string`):

Limit results to one FCC license status. Leave empty to include all statuses.

## `frequencyFromMhz` (type: `number`):

Lowest frequency in an inclusive range. Enter both bounds; use equal values for an exact frequency.

## `frequencyToMhz` (type: `number`):

Highest frequency in the inclusive range. It must be greater than or equal to the lower bound.

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

Stop after saving this many successful, deduplicated license records.

## `lookbackDays` (type: `integer`):

Include licensing activity from this many days before the run date.

## `eventType` (type: `string`):

FCC licensing event type or code to include. Leave empty to include every event type in the look-back period.

## `activityMaxItems` (type: `integer`):

Stop after saving this many successful, deduplicated licensing-activity records.

## `coordinates` (type: `array`):

Enter one coordinate per line as `latitude, longitude`, optionally prefixed with a label and `|`, for example `Tower A | 38.8977, -77.0365`. Labels are preserved in successful results.

## Actor input object example

```json
{
  "target": "coordinates",
  "matchType": "partial",
  "maxItems": 100,
  "lookbackDays": 7,
  "activityMaxItems": 100,
  "coordinates": [
    "White House | 38.8977, -77.0365",
    "Golden Gate Bridge | 37.8199, -122.4783"
  ]
}
```

# Actor output Schema

## `results` (type: `string`):

Review successful FCC ULS license, licensing-activity, and coordinate-geography rows in the overview.

# 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 = {
    "target": "coordinates",
    "coordinates": [
        "White House | 38.8977, -77.0365",
        "Golden Gate Bridge | 37.8199, -122.4783"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("maximedupre/fcc-license-search-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 = {
    "target": "coordinates",
    "coordinates": [
        "White House | 38.8977, -77.0365",
        "Golden Gate Bridge | 37.8199, -122.4783",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("maximedupre/fcc-license-search-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 '{
  "target": "coordinates",
  "coordinates": [
    "White House | 38.8977, -77.0365",
    "Golden Gate Bridge | 37.8199, -122.4783"
  ]
}' |
apify call maximedupre/fcc-license-search-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=maximedupre/fcc-license-search-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "FCC License Search",
        "description": "Search public FCC license records by call sign, licensee, location, service, status, or frequency. Export structured license details or look up U.S. census geography from coordinates.",
        "version": "0.1",
        "x-build-id": "5vebR9J6bC6Xy2Rqt"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/maximedupre~fcc-license-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-maximedupre-fcc-license-search-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/maximedupre~fcc-license-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-maximedupre-fcc-license-search-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/maximedupre~fcc-license-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-maximedupre-fcc-license-search-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",
                "required": [
                    "target"
                ],
                "properties": {
                    "target": {
                        "title": "Target",
                        "enum": [
                            "licenses",
                            "activity",
                            "coordinates"
                        ],
                        "type": "string",
                        "description": "Choose the FCC public-record result family to collect."
                    },
                    "callSign": {
                        "title": "Call sign",
                        "type": "string",
                        "description": "FCC call sign, for example W1AW or KQED."
                    },
                    "licenseeName": {
                        "title": "Licensee or applicant name",
                        "type": "string",
                        "description": "License holder, organization, or applicant name, for example Verizon or KQED Inc."
                    },
                    "matchType": {
                        "title": "Text matching",
                        "enum": [
                            "partial",
                            "exact"
                        ],
                        "type": "string",
                        "description": "Apply partial or exact matching to the call sign and licensee or applicant name.",
                        "default": "partial"
                    },
                    "city": {
                        "title": "City",
                        "type": "string",
                        "description": "License or applicant location city, for example San Francisco."
                    },
                    "state": {
                        "title": "State or territory",
                        "pattern": "^[A-Za-z]{2}$",
                        "minLength": 2,
                        "maxLength": 2,
                        "type": "string",
                        "description": "Two-letter U.S. state or territory code, for example CA, TX, or PR."
                    },
                    "zipCode": {
                        "title": "ZIP code",
                        "pattern": "^[0-9]{5}(-[0-9]{4})?$",
                        "type": "string",
                        "description": "Five-digit U.S. ZIP code or ZIP+4, for example 94105 or 94105-1234."
                    },
                    "radioServiceCode": {
                        "title": "Radio service",
                        "type": "string",
                        "description": "FCC radio service code or name, such as AM, FM, HA, microwave, paging, cellular, aviation, or marine."
                    },
                    "licenseClass": {
                        "title": "License class",
                        "type": "string",
                        "description": "FCC license class code or name."
                    },
                    "licenseStatus": {
                        "title": "License status",
                        "enum": [
                            "A",
                            "C",
                            "E",
                            "T"
                        ],
                        "type": "string",
                        "description": "Limit results to one FCC license status. Leave empty to include all statuses."
                    },
                    "frequencyFromMhz": {
                        "title": "Frequency from (MHz)",
                        "minimum": 0,
                        "type": "number",
                        "description": "Lowest frequency in an inclusive range. Enter both bounds; use equal values for an exact frequency."
                    },
                    "frequencyToMhz": {
                        "title": "Frequency to (MHz)",
                        "minimum": 0,
                        "type": "number",
                        "description": "Highest frequency in the inclusive range. It must be greater than or equal to the lower bound."
                    },
                    "maxItems": {
                        "title": "Maximum license results",
                        "minimum": 1,
                        "maximum": 2000,
                        "type": "integer",
                        "description": "Stop after saving this many successful, deduplicated license records.",
                        "default": 100
                    },
                    "lookbackDays": {
                        "title": "Look-back period (days)",
                        "minimum": 1,
                        "maximum": 365,
                        "type": "integer",
                        "description": "Include licensing activity from this many days before the run date.",
                        "default": 7
                    },
                    "eventType": {
                        "title": "Event type",
                        "type": "string",
                        "description": "FCC licensing event type or code to include. Leave empty to include every event type in the look-back period."
                    },
                    "activityMaxItems": {
                        "title": "Maximum activity results",
                        "minimum": 1,
                        "maximum": 2000,
                        "type": "integer",
                        "description": "Stop after saving this many successful, deduplicated licensing-activity records.",
                        "default": 100
                    },
                    "coordinates": {
                        "title": "Coordinates",
                        "minItems": 1,
                        "maxItems": 500,
                        "type": "array",
                        "description": "Enter one coordinate per line as `latitude, longitude`, optionally prefixed with a label and `|`, for example `Tower A | 38.8977, -77.0365`. Labels are preserved in successful results.",
                        "items": {
                            "type": "string"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
