# NASBA CPA License Verifier (`automation-lab/nasba-cpa-license-verifier`) Actor

Verify public NASBA CPAverify license rows by CPA name, license number, status, and jurisdiction. Export structured compliance-ready data.

- **URL**: https://apify.com/automation-lab/nasba-cpa-license-verifier.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

## NASBA CPA License Verifier

Search public CPA license rows from NASBA CPAverify and export structured license-verification data from Apify.

### What does NASBA CPA License Verifier do?

NASBA CPA License Verifier turns CPAverify search results into clean dataset rows.

It searches the public NASBA CPAverify license database by CPA name, license number, and jurisdiction filters.

The actor saves license rows with names, license numbers, statuses, jurisdictions, license types, and disciplinary flags when CPAverify exposes them.

### Who is it for?

Compliance teams use it to check CPA license status before onboarding or renewal.

Accounting firms use it to audit lists of professionals and confirm public status details.

Recruiters use it to verify candidate license information during screening.

Data teams use it to enrich internal records with public CPAverify status fields.

Market researchers use it to collect structured public license search rows for analysis.

### Why use this actor?

✅ It is HTTP-first and lightweight.

✅ It outputs structured rows instead of copied web pages.

✅ It includes traceability fields such as search URL, input values, result page, and scrape timestamp.

✅ It supports polite pagination controls and small default limits.

✅ It avoids PDF/download flows in v1 to keep runs reliable and affordable.

### What data can you extract?

| Field | Description |
| --- | --- |
| `name` | CPAverify licensee name |
| `licenseNumber` | Public license number |
| `licenseStatus` | Status label such as ACTIVE, EXPIRED, or DECEASED |
| `active` | Boolean active indicator when present |
| `jurisdictionAbbreviation` | Board/state abbreviation |
| `jurisdictionName` | Full board name |
| `licenseTypeDescription` | License type text |
| `disciplinaryAction` | Public disciplinary action flag |
| `licenseeId` | CPAverify row identifier |
| `searchUrl` | Result page URL fetched |
| `scrapedAt` | Timestamp when the row was saved |

### How much does it cost to verify NASBA CPA licenses?

This actor uses pay-per-event pricing.

There is a small start event for each run.

There is a per-license-row event for each saved CPAverify result row.

Use `maxItems` to control run size and cost.

Start with the prefilled example input before scaling to larger searches.

### How to run it

1. Open the actor on Apify.

2. Enter a CPA last name or license number.

3. Optionally add first name, jurisdiction ID, or jurisdiction abbreviation.

4. Set `maxItems` to the maximum rows you want.

5. Run the actor.

6. Download results as JSON, CSV, Excel, XML, or HTML from the Apify dataset.

### Input options

#### Search terms

`lastName` searches CPAverify by last name.

`firstName` narrows the result set.

`middleName` narrows the result set when known.

`maiden` searches the CPAverify maiden-name field.

`licenseNum` searches by public license number.

#### Jurisdiction filters

`jurisdictionId` is the numeric CPAverify jurisdiction identifier.

`jurisdictionAbbreviation` filters saved rows after extraction, for example `NC`, `VA`, `IN`, or `CA`.

#### Limits and pagination

`maxItems` controls the number of saved rows.

`pageSize` controls requested rows per CPAverify page.

`startPage` starts from a zero-based page index.

`maxPages` caps pagination.

`requestDelaySecs` adds a polite delay between page requests.

### Example input

```json
{
  "lastName": "Smith",
  "firstName": "John",
  "maxItems": 25,
  "pageSize": 25,
  "maxPages": 2,
  "requestDelaySecs": 1
}
````

### Example output

```json
{
  "source": "NASBA CPAverify",
  "name": "ANDREW JOHN SMITH",
  "licenseNumber": "38252",
  "licenseStatus": "DECEASED",
  "active": false,
  "jurisdictionAbbreviation": "NC",
  "jurisdictionName": "NORTH CAROLINA STATE BOARD OF CPA EXAMINERS",
  "disciplinaryAction": "N",
  "resultPage": 0,
  "resultIndex": 1
}
```

### Tips for accurate searches

Use both last name and first name when possible.

Use a license number when you need a very narrow search.

Use jurisdiction filters to reduce noisy common-name searches.

Keep `maxItems` low for initial checks.

Increase `maxPages` only when CPAverify reports more pages.

### Pagination behavior

CPAverify results are paginated.

The actor starts at `startPage` and continues until it reaches `maxItems`, `maxPages`, or the source reports no next page.

`resultPage` is zero-based to match the source pagination parameter.

`resultIndex` is one-based within the actor run.

### Data quality notes

CPAverify rows may contain inactive, expired, deceased, or non-renewable statuses.

The actor does not reinterpret status text.

It preserves CPAverify public fields as structured output.

Some fields are optional because not every jurisdiction sends the same metadata.

### Integrations

Use this actor in an Apify task to schedule recurring license checks.

Connect the dataset to Google Sheets for compliance review queues.

Send run results to Make or Zapier via Apify webhooks.

Export JSON from the Apify API into an internal onboarding workflow.

Combine with your CRM to flag records that need manual license review.

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/nasba-cpa-license-verifier').call({
  lastName: 'Smith',
  firstName: 'John',
  maxItems: 25
});
console.log(run.defaultDatasetId);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('MY-APIFY-TOKEN')
run = client.actor('automation-lab/nasba-cpa-license-verifier').call(run_input={
    'lastName': 'Smith',
    'firstName': 'John',
    'maxItems': 25,
})
print(run['defaultDatasetId'])
```

### API usage with cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~nasba-cpa-license-verifier/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"lastName":"Smith","firstName":"John","maxItems":25}'
```

### MCP usage

Use the Apify MCP server with tools enabled for this actor:

`https://mcp.apify.com/?tools=automation-lab/nasba-cpa-license-verifier`

Add it from Claude Code with:

```bash
claude mcp add apify-nasba-cpa-license-verifier https://mcp.apify.com/?tools=automation-lab/nasba-cpa-license-verifier
```

Claude Desktop JSON configuration example:

```json
{
  "mcpServers": {
    "apify-nasba-cpa-license-verifier": {
      "url": "https://mcp.apify.com/?tools=automation-lab/nasba-cpa-license-verifier"
    }
  }
}
```

#### MCP example prompts

Example prompts showing MCP usage:

- "Use the Apify MCP tool `automation-lab/nasba-cpa-license-verifier` to run NASBA CPA License Verifier for last name Smith and first name John, then summarize active licenses by jurisdiction."

- "Use MCP to verify CPAverify rows for license number 38252 with last name Smith and return the license statuses."

- "Use the NASBA CPA License Verifier MCP tool to search CPAverify for last name Johnson in NC and create a table with license number, status, board, and disciplinary flag."

Example Claude Desktop workflow:

1. Add the Apify MCP server.

2. Enable `automation-lab/nasba-cpa-license-verifier`.

3. Ask Claude to run a small search.

4. Ask Claude to inspect the dataset and produce a review table.

### Legality and ethical use

This actor extracts public CPAverify search-result data.

Use it responsibly and respect CPAverify terms and applicable laws.

Do not use the actor for harassment, spam, or automated decisions without appropriate human review.

Throttle searches and avoid unnecessary repeated queries.

### Limitations

v1 extracts search-result rows only.

It does not download PDFs.

It does not click through private or account-only flows.

It does not guarantee that every board sends complete data to CPAverify.

Hawaii and New Mexico may not be represented in CPAverify results according to the site messaging.

### FAQ

#### Is NASBA CPAverify public data?

CPAverify exposes public search-result rows without an account, but you should still use the data responsibly and follow applicable terms and laws.

#### Does this actor download PDFs?

No. v1 extracts search-result rows only and intentionally avoids PDF/download flows.

### Troubleshooting

#### Why did I get no results?

Check the spelling of the last name, first name, and license number.

Try removing optional filters such as jurisdiction abbreviation.

Try increasing `maxPages` if the result appears on a later page.

#### Why are some fields null?

CPAverify does not expose every field for every row.

The actor keeps optional fields as null rather than inventing values.

#### Why did I get fewer rows than `maxItems`?

The source may have fewer matching rows, or your jurisdiction abbreviation filter may exclude rows after extraction.

### Related scrapers

Browse more Automation Lab actors at https://apify.com/automation-lab/.

Useful related workflows include lead enrichment, public registry checks, and compliance monitoring actors.

### Changelog

Initial version: public CPAverify result extraction with name, license number, jurisdiction, status, pagination, and per-license-row charging.

### Support

If you need a new field from CPAverify search rows, open an issue on the actor page with a sample input and expected output.

If a run fails, include the run URL and input so Support can reproduce it.

# Actor input Schema

## `lastName` (type: `string`):

CPA last name to search. Required by CPAverify for name searches unless you provide a license number.

## `firstName` (type: `string`):

Optional CPA first name to narrow the search.

## `middleName` (type: `string`):

Optional middle name filter.

## `maiden` (type: `string`):

Optional maiden name filter exposed by CPAverify.

## `licenseNum` (type: `string`):

Optional CPA license number search term.

## `jurisdictionId` (type: `string`):

Optional numeric CPAverify jurisdiction ID if known. Example: 34 for North Carolina in current CPAverify data.

## `jurisdictionAbbreviation` (type: `string`):

Optional post-extraction filter by state/board abbreviation, such as NC, VA, IN, or CA.

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

Maximum number of CPA license rows to save.

## `pageSize` (type: `integer`):

CPAverify page size request. Keep at 25 unless you need to tune pagination.

## `startPage` (type: `integer`):

Zero-based CPAverify result page to start from.

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

Safety cap for the number of result pages to request.

## `requestDelaySecs` (type: `integer`):

Polite delay between CPAverify page requests.

## Actor input object example

```json
{
  "lastName": "Smith",
  "firstName": "John",
  "maxItems": 20,
  "pageSize": 25,
  "startPage": 0,
  "maxPages": 10,
  "requestDelaySecs": 1
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "lastName": "Smith",
    "firstName": "John",
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/nasba-cpa-license-verifier").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 = {
    "lastName": "Smith",
    "firstName": "John",
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/nasba-cpa-license-verifier").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 '{
  "lastName": "Smith",
  "firstName": "John",
  "maxItems": 20
}' |
apify call automation-lab/nasba-cpa-license-verifier --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/nasba-cpa-license-verifier",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "NASBA CPA License Verifier",
        "description": "Verify public NASBA CPAverify license rows by CPA name, license number, status, and jurisdiction. Export structured compliance-ready data.",
        "version": "0.1",
        "x-build-id": "ZKYN2zDylI9fhkWkh"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~nasba-cpa-license-verifier/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-nasba-cpa-license-verifier",
                "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/automation-lab~nasba-cpa-license-verifier/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-nasba-cpa-license-verifier",
                "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/automation-lab~nasba-cpa-license-verifier/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-nasba-cpa-license-verifier",
                "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": {
                    "lastName": {
                        "title": "Last name",
                        "type": "string",
                        "description": "CPA last name to search. Required by CPAverify for name searches unless you provide a license number."
                    },
                    "firstName": {
                        "title": "First name",
                        "type": "string",
                        "description": "Optional CPA first name to narrow the search."
                    },
                    "middleName": {
                        "title": "Middle name",
                        "type": "string",
                        "description": "Optional middle name filter."
                    },
                    "maiden": {
                        "title": "Maiden name",
                        "type": "string",
                        "description": "Optional maiden name filter exposed by CPAverify."
                    },
                    "licenseNum": {
                        "title": "License number",
                        "type": "string",
                        "description": "Optional CPA license number search term."
                    },
                    "jurisdictionId": {
                        "title": "NASBA jurisdiction ID",
                        "type": "string",
                        "description": "Optional numeric CPAverify jurisdiction ID if known. Example: 34 for North Carolina in current CPAverify data."
                    },
                    "jurisdictionAbbreviation": {
                        "title": "Jurisdiction abbreviation",
                        "type": "string",
                        "description": "Optional post-extraction filter by state/board abbreviation, such as NC, VA, IN, or CA."
                    },
                    "maxItems": {
                        "title": "Maximum license rows",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of CPA license rows to save.",
                        "default": 20
                    },
                    "pageSize": {
                        "title": "Page size",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "CPAverify page size request. Keep at 25 unless you need to tune pagination.",
                        "default": 25
                    },
                    "startPage": {
                        "title": "Start page",
                        "minimum": 0,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Zero-based CPAverify result page to start from.",
                        "default": 0
                    },
                    "maxPages": {
                        "title": "Maximum pages",
                        "minimum": 1,
                        "maximum": 400,
                        "type": "integer",
                        "description": "Safety cap for the number of result pages to request.",
                        "default": 10
                    },
                    "requestDelaySecs": {
                        "title": "Delay between pages (seconds)",
                        "minimum": 0,
                        "maximum": 30,
                        "type": "integer",
                        "description": "Polite delay between CPAverify page requests.",
                        "default": 1
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
