# Seattle Restaurant Inspections Scraper (`automation-lab/seattle-restaurant-inspections-scraper`) Actor

Scrape King County / Seattle restaurant safety-rating records with names, grades, locations, phone numbers, and coordinates.

- **URL**: https://apify.com/automation-lab/seattle-restaurant-inspections-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Business
- **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

## Seattle Restaurant Inspections Scraper

Extract King County / Seattle restaurant safety-rating business records from the public ArcGIS FeatureServer. The actor returns food-business names, addresses, cities, ZIP codes, phone numbers, safety grades, establishment descriptions, statuses, coordinates, parcel identifiers, and source timestamps.

Use it when you need a repeatable dataset for restaurant compliance monitoring, local food-business lead intelligence, reputation tracking, or map-based market research in Seattle and King County.

### What does Seattle Restaurant Inspections Scraper do?

Seattle Restaurant Inspections Scraper downloads public restaurant safety-rating records published by King County.

It uses the official ArcGIS JSON endpoint behind the King County restaurant safety ratings search page, so no browser automation, login, CAPTCHA solving, or account is required.

The actor helps you turn a public map/search experience into structured rows that can be exported to CSV, Excel, JSON, Google Sheets, databases, CRMs, or BI tools.

### Who is it for?

- 🧑‍💼 Compliance teams monitoring restaurant safety ratings and food-business risk.
- 📍 Local lead-generation teams prospecting restaurants, cafes, convenience stores, and food-service locations.
- 🏢 Agencies and vendors selling cleaning, pest control, insurance, training, marketing, or reputation services to food businesses.
- 📊 Data teams building local business intelligence dashboards for Seattle and King County.
- 📰 Journalists and civic researchers tracking food-safety datasets over time.

### Why use this actor?

The King County website is useful for manual lookup, but repeated monitoring requires structured data.

This actor gives you:

- ✅ Direct public-source extraction from ArcGIS.
- ✅ Configurable city, business-name, status, grade, and date filters.
- ✅ Coordinates for map and territory workflows.
- ✅ Stable field names for automated pipelines.
- ✅ PPE pricing that scales with the number of records saved.

### Data source

The actor reads King County's public restaurant safety ratings data.

Source page:

https://kingcounty.gov/en/dept/dph/health-safety/food-safety/search-restaurant-safety-ratings

ArcGIS FeatureServer layer:

`EPL_BusinessPoint/FeatureServer/0`

The source is public and does not require credentials.

### What data can you extract?

| Field | Description |
| --- | --- |
| `businessRecordId` | King County business record identifier |
| `businessName` | Restaurant or food-business name |
| `programIdentifier` | Program identifier from the source |
| `establishmentDescription` | Establishment and risk/category description |
| `address` | Street address |
| `city` | Business city |
| `zipCode` | ZIP code |
| `phone` | Phone number when available |
| `safetyGrade` | King County safety grade |
| `businessStatus` | Business status, for example Active |
| `parcelNumber` | Parcel number for matching to property data |
| `latitude` / `longitude` | Map coordinates from ArcGIS geometry |
| `loadDate` | King County source load timestamp |
| `sourceUrl` | Public source page |
| `scrapedAt` | Actor run timestamp |

### How much does it cost to scrape Seattle restaurant inspections?

This actor uses pay-per-event pricing.

- A small start event is charged once per run.
- A per-record `item` event is charged for each saved restaurant / food-business record.

The exact tiered prices are shown on the Apify actor page. Keep `maxItems` low for quick smoke tests, then increase it for production exports.

### Input options

You can configure:

- `maxItems` — maximum number of records to save.
- `city` — exact city filter such as `Seattle`, `Bellevue`, `Kent`, or `Renton`.
- `businessName` — case-insensitive name contains filter.
- `statuses` — optional King County business status filter, usually `Active`.
- `grades` — optional safety-grade filter.
- `loadedFrom` and `loadedTo` — filter by King County source load date.
- `includeGeometry` — include point coordinates in the output.

### Example input: active Seattle records

```json
{
  "city": "Seattle",
  "statuses": ["Active"],
  "maxItems": 100,
  "includeGeometry": true
}
````

### Example input: find a restaurant or chain

```json
{
  "city": "Seattle",
  "businessName": "coffee",
  "statuses": ["Active"],
  "maxItems": 50,
  "includeGeometry": true
}
```

### Example input: safety-grade monitoring

```json
{
  "city": "Seattle",
  "grades": ["Good", "Okay", "Needs to Improve"],
  "statuses": ["Active"],
  "maxItems": 250,
  "includeGeometry": true
}
```

### Output example

```json
{
  "businessRecordId": "PFE-PR-3127011",
  "businessName": "AM-PM MINI MART",
  "programIdentifier": "",
  "establishmentDescription": "Seating 0-12 - Risk Category III",
  "address": "10822 ROOSEVELT WAY NE",
  "city": "Seattle",
  "zipCode": "98125",
  "phone": null,
  "safetyGrade": "Excellent",
  "businessStatus": "Active",
  "parcelNumber": "1160000025",
  "latitude": 47.708294,
  "longitude": -122.317333,
  "loadDate": "2026-07-04T...Z",
  "sourceUrl": "https://kingcounty.gov/en/dept/dph/health-safety/food-safety/search-restaurant-safety-ratings",
  "scrapedAt": "2026-07-05T...Z"
}
```

### How to run the actor

1. Open the actor on Apify.
2. Set your filters, such as city and maximum records.
3. Click **Start**.
4. Download the dataset as CSV, Excel, JSON, or through the API.
5. Schedule recurring runs if you want a monitoring feed.

### Tips for best results

- Start with `maxItems: 100` to verify the exact filters you want.
- Use `city` to reduce export size and focus on a local market.
- Use `businessName` for brand monitoring or specific restaurant lookup.
- Use `grades` for risk-based outreach workflows.
- Keep `statuses` set to `Active` when you only want currently active businesses.

### Integrations

Common workflows include:

- 📈 Send rows to Google Sheets for a local restaurant prospect list.
- 🗺️ Load coordinates into a map dashboard for territory planning.
- 🧾 Join parcel numbers to property or permitting datasets.
- 🔔 Schedule weekly runs to detect source updates by `loadDate`.
- 🧩 Enrich CRM accounts with public safety-grade and location data.

### API usage: Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/seattle-restaurant-inspections-scraper').call({
  city: 'Seattle',
  statuses: ['Active'],
  maxItems: 100,
  includeGeometry: true,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### API usage: Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/seattle-restaurant-inspections-scraper').call(run_input={
    'city': 'Seattle',
    'statuses': ['Active'],
    'maxItems': 100,
    'includeGeometry': True,
})

items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### API usage: cURL

```bash
curl "https://api.apify.com/v2/acts/automation-lab~seattle-restaurant-inspections-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"city":"Seattle","statuses":["Active"],"maxItems":100,"includeGeometry":true}'
```

### MCP usage

Use this actor from MCP-compatible tools through Apify MCP.

Claude Code quick add command:

```bash
claude mcp add apify-seattle-restaurant-inspections --transport http https://mcp.apify.com/?tools=automation-lab/seattle-restaurant-inspections-scraper
```

Claude Desktop JSON config example:

```json
{
  "mcpServers": {
    "apify-seattle-restaurant-inspections": {
      "url": "https://mcp.apify.com/?tools=automation-lab/seattle-restaurant-inspections-scraper"
    }
  }
}
```

Claude Desktop / Claude Code MCP URL:

`https://mcp.apify.com/?tools=automation-lab/seattle-restaurant-inspections-scraper`

Example prompts:

- "Run the Seattle restaurant inspections scraper for Active Seattle businesses and summarize records with non-excellent grades."
- "Export King County restaurant safety records for Bellevue and prepare a lead list grouped by ZIP code."
- "Find public restaurant safety records where the business name contains coffee."

### Scheduling and monitoring

You can schedule the actor daily, weekly, or monthly.

For monitoring, keep input filters stable and compare new exports by `businessRecordId`, `safetyGrade`, `businessStatus`, and `loadDate`.

### Limitations

The current public ArcGIS layer exposes business safety-rating records and related location fields. It does not expose a separate row per individual inspection event in this layer. If King County changes the public ArcGIS service, field availability can change.

### Legality

This actor extracts public government data from a public endpoint. You are responsible for using the output lawfully, respecting privacy rules, and following Apify's terms and applicable laws. Avoid using public records for unlawful discrimination, harassment, or spam.

### FAQ

#### Is it legal to scrape this data?

The source is public government data, but you remain responsible for compliant use of the exported records.

### Troubleshooting

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

Your filters may be narrow, or the source may not have that many matching records. Try removing `businessName`, `grades`, or date filters.

#### Why is `phone` empty for some records?

The King County source does not publish phone numbers for every business record. Empty source values are returned as `null`.

#### Why do date filters use `loadDate`?

The public layer exposes a King County load timestamp. The actor filters on that source timestamp, not on hidden inspection-event dates that are not present in this layer.

### Related Apify actors

- https://apify.com/automation-lab/nyc-restaurant-inspections-scraper
- https://apify.com/automation-lab/google-maps-scraper
- https://apify.com/automation-lab/business-address-scraper

### Support

If you need a field that is visible on a King County page but missing from the dataset, open an Apify issue with the source page URL and an example business name.

### Changelog

Initial version extracts King County restaurant safety-rating business records through the public ArcGIS API.

# Actor input Schema

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

Maximum number of restaurant inspection / safety-rating business records to save.

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

Filter by business city, for example Seattle, Bellevue, Kent, or Renton. Leave empty for all King County cities.

## `businessName` (type: `string`):

Case-insensitive substring filter for restaurant or food business names.

## `statuses` (type: `array`):

Optional status filter from the King County source.

## `grades` (type: `array`):

Optional safety-rating grades to include, such as Excellent, Good, Okay, or Needs to Improve.

## `loadedFrom` (type: `string`):

Keep records whose King County load timestamp is on or after this date (YYYY-MM-DD).

## `loadedTo` (type: `string`):

Keep records whose King County load timestamp is on or before this date (YYYY-MM-DD).

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

Return ArcGIS point geometry as latitude and longitude fields.

## Actor input object example

```json
{
  "maxItems": 20,
  "city": "Seattle",
  "statuses": [
    "Active"
  ],
  "includeGeometry": true
}
```

# 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 = {
    "maxItems": 20,
    "city": "Seattle",
    "statuses": [
        "Active"
    ],
    "includeGeometry": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/seattle-restaurant-inspections-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "maxItems": 20,
    "city": "Seattle",
    "statuses": ["Active"],
    "includeGeometry": True,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/seattle-restaurant-inspections-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "maxItems": 20,
  "city": "Seattle",
  "statuses": [
    "Active"
  ],
  "includeGeometry": true
}' |
apify call automation-lab/seattle-restaurant-inspections-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Seattle Restaurant Inspections Scraper",
        "description": "Scrape King County / Seattle restaurant safety-rating records with names, grades, locations, phone numbers, and coordinates.",
        "version": "0.1",
        "x-build-id": "G4dY2y2dI8hXcCqKP"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~seattle-restaurant-inspections-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-seattle-restaurant-inspections-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~seattle-restaurant-inspections-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-seattle-restaurant-inspections-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~seattle-restaurant-inspections-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-seattle-restaurant-inspections-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": {
                    "maxItems": {
                        "title": "Maximum records",
                        "minimum": 1,
                        "maximum": 50000,
                        "type": "integer",
                        "description": "Maximum number of restaurant inspection / safety-rating business records to save.",
                        "default": 20
                    },
                    "city": {
                        "title": "City",
                        "type": "string",
                        "description": "Filter by business city, for example Seattle, Bellevue, Kent, or Renton. Leave empty for all King County cities."
                    },
                    "businessName": {
                        "title": "Business name contains",
                        "type": "string",
                        "description": "Case-insensitive substring filter for restaurant or food business names."
                    },
                    "statuses": {
                        "title": "Business statuses",
                        "type": "array",
                        "description": "Optional status filter from the King County source.",
                        "items": {
                            "type": "string"
                        },
                        "default": [
                            "Active"
                        ]
                    },
                    "grades": {
                        "title": "Safety grades",
                        "type": "array",
                        "description": "Optional safety-rating grades to include, such as Excellent, Good, Okay, or Needs to Improve.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "loadedFrom": {
                        "title": "Loaded from date",
                        "type": "string",
                        "description": "Keep records whose King County load timestamp is on or after this date (YYYY-MM-DD)."
                    },
                    "loadedTo": {
                        "title": "Loaded to date",
                        "type": "string",
                        "description": "Keep records whose King County load timestamp is on or before this date (YYYY-MM-DD)."
                    },
                    "includeGeometry": {
                        "title": "Include map coordinates",
                        "type": "boolean",
                        "description": "Return ArcGIS point geometry as latitude and longitude fields.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```