# Clark County Property Records Scraper (`automation-lab/clark-county-property-records-scraper`) Actor

🏠 Extract official Clark County parcel owners, ownership history, tax districts, acreage, legal descriptions, and optional GIS polygons.

- **URL**: https://apify.com/automation-lab/clark-county-property-records-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Real estate
- **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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## Clark County Property Records Scraper

Extract official Clark County, Nevada parcel ownership and GIS records without a browser or login.

Turn APNs or ArcGIS parcel filters into structured records containing owners, ownership history, tax districts, legal descriptions, acreage, parcel type, and optional polygon geometry.

### What does Clark County Property Records Scraper do?

This Actor combines two public Clark County sources:

- 🏠 Clark County Assessor parcel ownership history
- 🗺️ GISMO AssessorMapv2 parcel geometry
- 📄 Recorder document and vesting details when published
- 📐 Assessed acreage, area, and perimeter
- 🔁 Current and prior ownership records

Each parcel becomes one clean dataset item.

No login is required.

No browser automation is used.

### Who is it for?

#### Real-estate investors and wholesalers

Build owner lists from a tax district or parcel query.

Review prior ownership before outreach.

Export records to a CRM or spreadsheet.

#### Title and property researchers

Verify the Assessor's current owner.

Retain source URLs for audit trails.

Compare current and prior vesting.

#### Portfolio operators

Schedule recurring parcel refreshes.

Detect ownership changes downstream.

Join APNs to internal property data.

#### GIS analysts

Retrieve Clark County parcel polygons.

Use object IDs for source reconciliation.

Filter the official ArcGIS layer directly.

### Why use this property records scraper?

Manual parcel lookup is practical for one address, but not for hundreds of records.

This Actor provides:

- repeatable APN normalization
- bulk parcel discovery
- ownership-history enrichment
- structured JSON, CSV, Excel, and XML exports
- Apify API and webhook compatibility
- conservative HTTP requests
- source attribution in every row

### What Clark County property data can I extract?

| Field | Description |
|---|---|
| `parcelNumber` | Normalized 11-digit APN |
| `owner` | Current Assessor owner |
| `ownershipPercent` | Published ownership share |
| `documentNumber` | Recorder document number |
| `recordDate` | Published record date |
| `vesting` | Ownership vesting code |
| `taxDistrict` | Clark County tax district |
| `estimatedSize` | Assessor size text |
| `assessorDescription` | Official legal/parcel description |
| `priorOwners` | Prior ownership records |
| `assessedAcres` | GIS assessed acreage |
| `calculatedAcres` | GIS calculated acreage |
| `parcelType` | GIS parcel type code |
| `area` | Polygon area from GISMO |
| `perimeter` | Polygon perimeter from GISMO |
| `geometry` | Optional polygon rings |
| `assessorUrl` | Official parcel history URL |
| `gisObjectId` | GIS layer object ID |
| `scrapedAt` | UTC extraction timestamp |

Fields not published by the source are omitted rather than fabricated.

### How to scrape Clark County property records

1. Open the Actor input page.
2. Enter one or more parcel numbers.
3. Keep **Include ownership history** enabled.
4. Choose whether to include polygon geometry.
5. Set a safe maximum record count.
6. Click **Start**.
7. Export the dataset in your preferred format.

For a broad list, leave parcel numbers empty and provide an ArcGIS `where` clause.

### Input

#### Parcel numbers

Enter Clark County APNs with or without punctuation.

Examples:

- `163-03-715-001`
- `16303715001`

Only valid 11-digit APNs are used for direct lookup.

#### ArcGIS where clause

Use this advanced option for parcel discovery.

Examples:

- `1=1`
- `TAX_DIST='200'`
- `PARCELTYPE=0`
- `OID BETWEEN 1 AND 500`

The clause is sent to Clark County's public GIS service.

#### Maximum parcel records

`maxItems` controls dataset size.

Start with 20 while testing a query; this matches the default and prefilled limit.

Increase it for production exports.

#### Ownership history and geometry

Ownership enrichment adds one Assessor request per parcel.

Disable it for faster GIS-only inventories.

Geometry can be large, so enable it only when needed.

### Example input

```json
{
  "parcelNumbers": ["163-03-715-001"],
  "maxItems": 1,
  "includeHistory": true,
  "includeGeometry": false
}
````

Bulk district example:

```json
{
  "parcelNumbers": [],
  "where": "TAX_DIST='200'",
  "maxItems": 100,
  "includeHistory": true,
  "includeGeometry": false
}
```

### Example output

```json
{
  "parcelNumber": "16303715001",
  "owner": "EXAMPLE OWNER",
  "vesting": "NS",
  "taxDistrict": "200",
  "assessorDescription": "SUBDIVISION LOT AND BLOCK DESCRIPTION",
  "priorOwners": [
    {
      "owner": "PRIOR OWNER",
      "recordDate": "03/16/2017",
      "vesting": "NS"
    }
  ],
  "assessedAcres": 0.47,
  "parcelType": 0,
  "assessorUrl": "https://maps.clarkcountynv.gov/assessor/AssessorParcelDetail/ParcelHistory.aspx?instance=pcl2&parcel=16303715001",
  "scrapedAt": "2026-07-13T00:00:00.000Z"
}
```

The example names are illustrative.

Live values come from Clark County.

### How much does it cost to scrape Clark County property records?

The Actor uses pay-per-event pricing.

A small start event covers run initialization.

A result event is charged for each saved parcel.

Your Apify plan determines the exact tier price shown before a run.

To control cost:

- begin with a low `maxItems`
- test a narrow `where` clause
- disable history for GIS-only work
- omit geometry unless required

You never pay for parcel rows that are not saved.

### Tips for reliable parcel research

- Prefer APNs over owner names for exact matching.
- Remove duplicate APNs before large runs.
- Save the `assessorUrl` for verification.
- Treat ownership data as a research lead, not legal advice.
- Schedule reasonable refresh intervals.
- Use narrower tax-district or object-ID filters for batches.
- Keep geometry disabled for lightweight spreadsheets.
- Preserve leading zeroes in APNs as text.

### Integrations

#### Google Sheets

Connect the dataset to Google Sheets for an owner research workbook.

Use APN as the stable join key.

#### Airtable

Create a parcel table and link it to outreach or due-diligence records.

#### Webhooks

Trigger an automation when a scheduled run finishes.

Compare new owner values to your previous snapshot.

#### Zapier and Make

Send new parcel records into CRM, email, or task workflows.

#### Cloud storage

Download JSON, CSV, Excel, XML, or RSS from the dataset API.

### API usage with JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/clark-county-property-records-scraper').call({
  parcelNumbers: ['163-03-715-001'],
  includeHistory: true,
  maxItems: 1,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/clark-county-property-records-scraper').call(run_input={
    'parcelNumbers': ['163-03-715-001'],
    'includeHistory': True,
    'maxItems': 1,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### API usage with cURL

```bash
curl -X POST \
  'https://api.apify.com/v2/acts/automation-lab~clark-county-property-records-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"parcelNumbers":["163-03-715-001"],"maxItems":1}'
```

Fetch the default dataset after the run succeeds.

### Use with Apify MCP

Connect an AI assistant through:

`https://mcp.apify.com/?tools=automation-lab/clark-county-property-records-scraper`

Example prompts:

- “Look up Clark County APN 163-03-715-001.”
- “Export 100 parcels in tax district 200.”
- “Return GIS acreage without ownership history.”
- “Compare these parcel owners with my CRM list.”

The same Actor works from Claude Code, Claude Desktop, and MCP-compatible clients.

### Scheduling and monitoring

Create an Apify schedule for recurring portfolio checks.

Recommended workflow:

1. Store the parcel APNs in task input.
2. Run weekly or monthly.
3. Export each dated dataset.
4. Compare owner and record-date fields.
5. Notify your team when values change.

This Actor returns snapshots; change detection belongs in your downstream workflow.

### Data quality and limitations

The Actor reads public Clark County systems.

Availability and field coverage depend on those systems.

Some records may omit:

- ownership percentage
- recorder document number
- calculated acreage
- prior ownership rows
- geometry

Assessor and GIS values can differ because they serve different operational purposes.

Polygon coordinates use the source layer's spatial reference.

The Actor does not geocode street addresses.

It does not provide legal title insurance.

### Legality of scraping Clark County property records

The Actor accesses public government records without bypassing authentication.

You are responsible for your use of the data.

Follow applicable privacy, outreach, fair-housing, consumer-protection, and records laws.

Respect Clark County source terms and operational capacity.

Do not use the data for harassment, discrimination, or unlawful profiling.

Consult qualified counsel for legal-title decisions.

### Troubleshooting

#### Why did my query return no parcels?

Check the ArcGIS field name and quote string values.

Try a small `1=1` query to verify connectivity.

Confirm direct APNs contain exactly 11 digits.

#### Why is ownership history missing?

The Assessor may not publish history for every parcel.

Run again later if the source is temporarily unavailable.

The GIS record is still saved when history enrichment fails.

#### Why is the output large?

Polygon geometry can contain many coordinate pairs.

Set `includeGeometry` to `false` for compact exports.

#### Why is an acreage value zero?

Zero is an official source value, not a missing-value placeholder.

Compare `assessedAcres`, `calculatedAcres`, and the Assessor description.

### FAQ

#### Can I search by owner name?

Use an ArcGIS `where` clause only for fields exposed by the parcel layer. Direct owner-name discovery is not currently available because ownership comes from the Assessor detail surface.

#### Can I search by address?

The current Actor is APN and GIS-filter first. Resolve an address to an APN before direct lookup.

#### Does it return prior owners?

Yes, when Clark County publishes prior ownership rows and `includeHistory` is enabled.

#### Can it export parcel polygons?

Yes. Enable `includeGeometry` to include ArcGIS polygon rings.

#### Can I run thousands of parcels?

Yes, subject to the source and Actor limits. Start with a bounded sample and schedule polite batches.

#### Is an APN preserved with hyphens?

Output APNs are normalized to 11 digits for reliable joins.

### Related scrapers

Explore other public-record and real-estate tools from [automation-lab](https://apify.com/automation-lab).

Use this Actor specifically for Clark County, Nevada parcel ownership and GIS records.

For another jurisdiction, choose a source-specific actor whose output comes from that jurisdiction's official systems.

### Support

If a valid Clark County APN stops returning a record, open an Actor issue with:

- the APN or bounded `where` clause
- whether history was enabled
- the run URL
- the expected source record

Do not include private credentials or unrelated personal data.

# Actor input Schema

## `parcelNumbers` (type: `array`):

Clark County 11-digit APNs. Hyphens are accepted.

## `where` (type: `string`):

Advanced ArcGIS SQL filter used when parcel numbers are empty, for example TAX\_DIST='200'.

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

Maximum number of parcels to save.

## `includeHistory` (type: `boolean`):

Fetch current and prior ownership details from the Assessor for every parcel.

## `includeGeometry` (type: `boolean`):

Include ArcGIS polygon rings. Disable for smaller output.

## Actor input object example

```json
{
  "parcelNumbers": [
    "163-03-715-001"
  ],
  "where": "1=1",
  "maxItems": 20,
  "includeHistory": true,
  "includeGeometry": false
}
```

# 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 = {
    "parcelNumbers": [
        "163-03-715-001"
    ],
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/clark-county-property-records-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 = {
    "parcelNumbers": ["163-03-715-001"],
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/clark-county-property-records-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 '{
  "parcelNumbers": [
    "163-03-715-001"
  ],
  "maxItems": 20
}' |
apify call automation-lab/clark-county-property-records-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/clark-county-property-records-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Clark County Property Records Scraper",
        "description": "🏠 Extract official Clark County parcel owners, ownership history, tax districts, acreage, legal descriptions, and optional GIS polygons.",
        "version": "0.1",
        "x-build-id": "q2eahjynz3CeHyRFE"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~clark-county-property-records-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-clark-county-property-records-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/automation-lab~clark-county-property-records-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-clark-county-property-records-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/automation-lab~clark-county-property-records-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-clark-county-property-records-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": {
                    "parcelNumbers": {
                        "title": "🏠 Parcel numbers (APNs)",
                        "type": "array",
                        "description": "Clark County 11-digit APNs. Hyphens are accepted.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "where": {
                        "title": "ArcGIS where clause",
                        "type": "string",
                        "description": "Advanced ArcGIS SQL filter used when parcel numbers are empty, for example TAX_DIST='200'.",
                        "default": "1=1"
                    },
                    "maxItems": {
                        "title": "Maximum parcel records",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of parcels to save.",
                        "default": 20
                    },
                    "includeHistory": {
                        "title": "Include ownership history",
                        "type": "boolean",
                        "description": "Fetch current and prior ownership details from the Assessor for every parcel.",
                        "default": true
                    },
                    "includeGeometry": {
                        "title": "Include parcel geometry",
                        "type": "boolean",
                        "description": "Include ArcGIS polygon rings. Disable for smaller output.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```