# moveBuddha Moving Company Directory Scraper (`crawlerbros/movebuddha-moving-company-directory-scraper`) Actor

Scrape moveBuddha.com's ranked moving-company directory by city, state, or interstate route. Get company name, address, phone, rating, review count, DOT/state license numbers, and pricing for local and long-distance movers.

- **URL**: https://apify.com/crawlerbros/movebuddha-moving-company-directory-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Lead generation, Automation, SEO tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

## moveBuddha Moving Company Directory Scraper

Scrape moveBuddha.com's ranked moving-company directory — by city, by state, or by interstate route. Get company name, address, phone, star rating, review count, DOT/state license numbers, and (for interstate routes) price ranges. No login, no API key.

### What this actor does

- **Three search modes:** `byCity` (local movers ranked for one city), `byState` (top movers state-wide), `byRoute` (interstate movers for an origin → destination pair, with route pricing)
- **Long-distance variant:** `longDistanceOnly` switches `byCity`/`byState` to moveBuddha's separate, distinctly-curated long-distance/interstate movers listing for that city or state (a different set of companies than the local listing)
- **Rich structured data:** reads the same `MovingCompany` JSON-LD (schema.org) that powers Google's rich results, plus a DOM pass for DOT number / state license / rank
- **Filter:** minimum star rating
- **Empty fields are omitted** — fields only exist on records where moveBuddha actually publishes that data (e.g. DOT number is a local/state-mode-only field; price range is a route-mode-only field)

### Output per moving company

- `rank` — position in moveBuddha's ranked list for the searched area. Omitted (not fabricated) for a handful of national-brand entries (e.g. PODS, U-Haul, Penske) that `byCity`/`byState` pages include as blog-review-style listings outside the numbered ranking; always present on `byRoute` results, which are numbered by document order since route pages have no separate ranked list
- `companyName`, `logoUrl`
- `streetAddress`, `city`, `state`, `postalCode`, `country`, `fullAddress`
- `phone` — formatted `+1 (xxx) xxx-xxxx`
- `rating` (0–5), `reviewCount`
- `dotNumber` — USDOT number (local/state modes, when shown)
- `stateLicense` — state moving license number (local/state modes, when shown)
- `priceRange` — estimated cost range for the route (route mode only)
- `areaServed[]` — cities served (route mode only)
- `reviewSummary` — moveBuddha's data-driven review summary
- `positiveHighlights[]`, `negativeHighlights[]` — top themes from customer reviews
- `detailUrl` — the mover's own moveBuddha profile/review page
- `serviceArea` — the city/state/route searched
- `sourceUrl` — the directory page scraped
- `recordType: "movingCompany"`, `scrapedAt`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `byCity` | `byCity` / `byState` / `byRoute` |
| `state` | string | `tx` | US state (mode=byCity/byState) — 48 states supported |
| `city` | string | `Austin` | City name (mode=byCity), auto-slugified |
| `originState` | string | `ca` | Origin state (mode=byRoute) |
| `originCity` | string | `Los Angeles` | Origin city (mode=byRoute) |
| `destinationState` | string | `ny` | Destination state (mode=byRoute) |
| `destinationCity` | string | `New York City` | Destination city (mode=byRoute) |
| `longDistanceOnly` | bool | `false` | Scrape moveBuddha's separate long-distance/interstate movers listing instead of the local one (mode=byCity/byState) |
| `minRating` | int | – | Drop movers rated below this (0–5) |
| `maxItems` | int | `30` | Hard cap on emitted records (1–500) |

#### Example: local movers in a city

```json
{
  "mode": "byCity",
  "state": "tx",
  "city": "Austin",
  "minRating": 4,
  "maxItems": 25
}
````

#### Example: top movers in a state

```json
{
  "mode": "byState",
  "state": "ca",
  "maxItems": 20
}
```

#### Example: long-distance movers in a state

```json
{
  "mode": "byState",
  "state": "tx",
  "longDistanceOnly": true
}
```

#### Example: interstate route

```json
{
  "mode": "byRoute",
  "originState": "ca",
  "originCity": "Los Angeles",
  "destinationState": "ny",
  "destinationCity": "New York City"
}
```

### Use cases

- **Relocation planning** — compare ranked, reviewed movers for a specific city or long-distance route
- **Lead generation** — build territory lists of moving companies with contact info and DOT numbers
- **Competitive / market research** — track rating, review volume, and pricing by market or route
- **Compliance checks** — cross-reference DOT/state license numbers against FMCSA records
- **Content / comparison sites** — enrich a moving-company database with moveBuddha's curated rankings and review summaries

### FAQ

**What is moveBuddha?** An independent moving-industry review and comparison site that ranks local and long-distance movers using verified customer reviews, BBB ratings, and other signals.

**Why do some fields only appear for certain modes?** `dotNumber`/`stateLicense` come from the local/state-page profile panel, which route pages don't have (route pages instead show `priceRange` and `areaServed` for the specific corridor). This is real structural data, not a scraping gap.

**Which states are supported?** 48 US states with a dedicated moveBuddha directory page. Alaska, Hawaii, and Washington DC don't currently have published directory pages on moveBuddha and are not selectable.

**What if a route isn't a "popular route" on moveBuddha?** Only origin/destination pairs moveBuddha has published a route page for will return results (typically major-metro-to-major-metro pairs). Uncommon pairs return zero results with a status message rather than an error.

**How is `rank` determined?** It reflects moveBuddha's own ranking order for that city/state page (their proprietary blend of ratings, reviews, and BBB standing), not something the actor computes.

**Are DOT numbers verified?** They're published as-is from moveBuddha's listing; always cross-check against [FMCSA SAFER](https://safer.fmcsa.dot.gov/) before relying on them for compliance decisions.

**How many companies come back per search?** City and state pages both list moveBuddha's curated top ~16 movers for that area; route pages list a smaller set of interstate specialists (typically ~11). These are fixed-size curated lists on moveBuddha's own pages, not something the actor truncates — `maxItems` above the page's real count simply returns everything available.

# Actor input Schema

## `mode` (type: `string`):

How to search moveBuddha's moving-company directory.

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

US state to search movers in.

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

City name, e.g. `Austin`, `New York City`, `St. Louis`. Automatically slugified to match moveBuddha's URL pattern.

## `originState` (type: `string`):

Origin US state for a route search.

## `originCity` (type: `string`):

Origin city name for a route search, e.g. `Los Angeles`.

## `destinationState` (type: `string`):

Destination US state for a route search.

## `destinationCity` (type: `string`):

Destination city name for a route search, e.g. `New York City`.

## `longDistanceOnly` (type: `boolean`):

moveBuddha publishes a separate, distinctly-curated long-distance/interstate movers listing for each city and state (different companies than the local-movers listing). Set true to scrape that list instead of the local one. Ignored for mode=byRoute (route pages are long-distance by definition).

## `minRating` (type: `integer`):

Drop movers rated below this (0-5 stars). Enter a whole number; e.g. `4` keeps 4.0+ rated movers.

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

Hard cap on emitted records.

## Actor input object example

```json
{
  "mode": "byCity",
  "state": "tx",
  "city": "Austin",
  "originState": "ca",
  "originCity": "Los Angeles",
  "destinationState": "ny",
  "destinationCity": "New York City",
  "longDistanceOnly": false,
  "maxItems": 30
}
```

# Actor output Schema

## `movers` (type: `string`):

Dataset containing all scraped moving companies.

# 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 = {
    "mode": "byCity",
    "state": "tx",
    "city": "Austin",
    "originState": "ca",
    "originCity": "Los Angeles",
    "destinationState": "ny",
    "destinationCity": "New York City",
    "longDistanceOnly": false,
    "maxItems": 30
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/movebuddha-moving-company-directory-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 = {
    "mode": "byCity",
    "state": "tx",
    "city": "Austin",
    "originState": "ca",
    "originCity": "Los Angeles",
    "destinationState": "ny",
    "destinationCity": "New York City",
    "longDistanceOnly": False,
    "maxItems": 30,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/movebuddha-moving-company-directory-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 '{
  "mode": "byCity",
  "state": "tx",
  "city": "Austin",
  "originState": "ca",
  "originCity": "Los Angeles",
  "destinationState": "ny",
  "destinationCity": "New York City",
  "longDistanceOnly": false,
  "maxItems": 30
}' |
apify call crawlerbros/movebuddha-moving-company-directory-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=crawlerbros/movebuddha-moving-company-directory-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "moveBuddha Moving Company Directory Scraper",
        "description": "Scrape moveBuddha.com's ranked moving-company directory by city, state, or interstate route. Get company name, address, phone, rating, review count, DOT/state license numbers, and pricing for local and long-distance movers.",
        "version": "1.0",
        "x-build-id": "BQQ2A8IiZ9KTLt8RN"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~movebuddha-moving-company-directory-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-movebuddha-moving-company-directory-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/crawlerbros~movebuddha-moving-company-directory-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-movebuddha-moving-company-directory-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/crawlerbros~movebuddha-moving-company-directory-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-movebuddha-moving-company-directory-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Search mode",
                        "enum": [
                            "byCity",
                            "byState",
                            "byRoute"
                        ],
                        "type": "string",
                        "description": "How to search moveBuddha's moving-company directory.",
                        "default": "byCity"
                    },
                    "state": {
                        "title": "State (mode=byCity / byState)",
                        "enum": [
                            "al",
                            "ar",
                            "az",
                            "ca",
                            "co",
                            "ct",
                            "de",
                            "fl",
                            "ga",
                            "ia",
                            "id",
                            "il",
                            "in",
                            "ks",
                            "ky",
                            "la",
                            "ma",
                            "md",
                            "me",
                            "mi",
                            "mn",
                            "mo",
                            "ms",
                            "mt",
                            "nc",
                            "nd",
                            "ne",
                            "nh",
                            "nj",
                            "nm",
                            "nv",
                            "ny",
                            "oh",
                            "ok",
                            "or",
                            "pa",
                            "ri",
                            "sc",
                            "sd",
                            "tn",
                            "tx",
                            "ut",
                            "va",
                            "vt",
                            "wa",
                            "wi",
                            "wv",
                            "wy"
                        ],
                        "type": "string",
                        "description": "US state to search movers in.",
                        "default": "tx"
                    },
                    "city": {
                        "title": "City (mode=byCity)",
                        "type": "string",
                        "description": "City name, e.g. `Austin`, `New York City`, `St. Louis`. Automatically slugified to match moveBuddha's URL pattern.",
                        "default": "Austin"
                    },
                    "originState": {
                        "title": "Origin state (mode=byRoute)",
                        "enum": [
                            "al",
                            "ar",
                            "az",
                            "ca",
                            "co",
                            "ct",
                            "de",
                            "fl",
                            "ga",
                            "ia",
                            "id",
                            "il",
                            "in",
                            "ks",
                            "ky",
                            "la",
                            "ma",
                            "md",
                            "me",
                            "mi",
                            "mn",
                            "mo",
                            "ms",
                            "mt",
                            "nc",
                            "nd",
                            "ne",
                            "nh",
                            "nj",
                            "nm",
                            "nv",
                            "ny",
                            "oh",
                            "ok",
                            "or",
                            "pa",
                            "ri",
                            "sc",
                            "sd",
                            "tn",
                            "tx",
                            "ut",
                            "va",
                            "vt",
                            "wa",
                            "wi",
                            "wv",
                            "wy"
                        ],
                        "type": "string",
                        "description": "Origin US state for a route search.",
                        "default": "ca"
                    },
                    "originCity": {
                        "title": "Origin city (mode=byRoute)",
                        "type": "string",
                        "description": "Origin city name for a route search, e.g. `Los Angeles`.",
                        "default": "Los Angeles"
                    },
                    "destinationState": {
                        "title": "Destination state (mode=byRoute)",
                        "enum": [
                            "al",
                            "ar",
                            "az",
                            "ca",
                            "co",
                            "ct",
                            "de",
                            "fl",
                            "ga",
                            "ia",
                            "id",
                            "il",
                            "in",
                            "ks",
                            "ky",
                            "la",
                            "ma",
                            "md",
                            "me",
                            "mi",
                            "mn",
                            "mo",
                            "ms",
                            "mt",
                            "nc",
                            "nd",
                            "ne",
                            "nh",
                            "nj",
                            "nm",
                            "nv",
                            "ny",
                            "oh",
                            "ok",
                            "or",
                            "pa",
                            "ri",
                            "sc",
                            "sd",
                            "tn",
                            "tx",
                            "ut",
                            "va",
                            "vt",
                            "wa",
                            "wi",
                            "wv",
                            "wy"
                        ],
                        "type": "string",
                        "description": "Destination US state for a route search.",
                        "default": "ny"
                    },
                    "destinationCity": {
                        "title": "Destination city (mode=byRoute)",
                        "type": "string",
                        "description": "Destination city name for a route search, e.g. `New York City`.",
                        "default": "New York City"
                    },
                    "longDistanceOnly": {
                        "title": "Long-distance movers only (mode=byCity / byState)",
                        "type": "boolean",
                        "description": "moveBuddha publishes a separate, distinctly-curated long-distance/interstate movers listing for each city and state (different companies than the local-movers listing). Set true to scrape that list instead of the local one. Ignored for mode=byRoute (route pages are long-distance by definition).",
                        "default": false
                    },
                    "minRating": {
                        "title": "Minimum rating",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Drop movers rated below this (0-5 stars). Enter a whole number; e.g. `4` keeps 4.0+ rated movers."
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Hard cap on emitted records.",
                        "default": 30
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
