# Great Guys Move Scraper (`crawlerbros/greatguysmove-scraper`) Actor

Scrape Great Guys Moving's algorithmic ranking of 24,000+ moving companies across the US. Get overall scores, 11 quality-factor sub-scores, USDOT/state license verification, review counts, pros/cons, and full contact details by state, city, or company.

- **URL**: https://apify.com/crawlerbros/greatguysmove-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Automation, Lead generation, E-commerce
- **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

## Great Guys Move Scraper

Scrape **Great Guys Moving** — an algorithmic ranking directory covering more than 24,000 moving companies across the United States. Get each company's overall score, all 11 quality-factor sub-scores (quality, punctuality, affordability, communication, stick-to-prices, speed, friendliness, will-hire-again, professionalism, conflict handling, precision & care), USDOT/state license verification, review counts, pros/cons, service areas, and contact details — browsable by nation, state, city, or interstate route. HTTP-only, no login, no API key, no proxy required.

### What this actor does

- **Six modes:** `topNational`, `byState`, `byCity`, `stateCities`, `companyDetail`, `interstateMovers`
- **The 11 quality factors:** every company record includes the individual sub-score behind its overall ranking, not just the headline number
- **Quality-factor insights:** national percentile rank, an AI-written summary sentence, and real review-derived highlight quotes for each of the 11 factors (full-detail records)
- **License verification:** USDOT/FMCSA operating status, carrier legal name, MC number, plus state-level moving license data where available
- **Review intelligence:** review/data-point counts, rating tier (Exceptional / Superb / Fabulous / Very Good / Good), pros & cons summarized from real customer reviews, a year-by-year score history, and per-platform review links (Google, Yelp, BBB, Angi, Facebook, YellowPages, MyMovingReviews)
- **Local vs. long-distance:** `byCity` can fetch either a city's regular local-movers listing or its dedicated long-distance/interstate-specialist listing
- **Interstate routes:** look up the top movers specializing in a specific state-to-state route, plus the route's real driving distance and sample-size context
- **City discovery:** list every city Great Guys Moving covers in a given state
- **Moving-cost estimates:** optional city-level average cost by home size (studio through 5+ bedrooms)
- **Filters:** score range, minimum review count, rating tier, USDOT-authorized-only
- **Empty fields are omitted** — a field only appears on a record when real data was found for it

### Output per company

- `companyId`, `name`, `score` (0-10), `ratingAdjective`
- **11 quality sub-scores:** `qualityScore`, `punctualityScore`, `affordabilityScore`, `communicationScore`, `stickToPricesScore`, `speedScore`, `friendlinessScore`, `willHireAgainScore`, `professionalismScore`, `conflictHandlingScore`, `precisionAndCareScore`
- `qualityFactorInsights[]` — one entry per quality factor: `{factor, percentileRank, summary, mentions[]}` — national percentile rank, an AI-written summary sentence, and a handful of short review-derived highlight quotes for that factor (full-detail records)
- `scoreHistory[]` — `{year, score}` year-by-year overall-score trend (company detail / interstate route records)
- `affordabilityIndex`, `totalDataPoints`, `totalReviews`
- `nationalPercentile`, `statePercentile`, `topNationalPercent`, `betterThanInStateCount`, `betterThanInCityCount`, `cityRank`, `stateRank`
- `streetAddress`, `city`, `state`, `zip`, `phone`, `email`, `website`, `latitude`, `longitude`
- `bbbRating`, `bbbAccreditedSince`
- `usdot`, `usdotStatus`, `usdotLegalName`, `usdotDbaName`, `usdotMcNumber`, `usdotUrl`, `usdotPowerUnits`, `usdotDrivers`, `usdotLastUpdated`
- `stateLicenseNumber`, `stateLicenseStatus`, `stateLicenseUrl`
- `logoUrl`, `featuredImageUrl`, `awardImageUrls[]`, `ratingBadgeImageUrl`, `ratingBadgeUpdatedAt`
- `profileLive` — whether the company has claimed/activated a live shared profile link
- `bio`, `metaDescription`, `servicesOffered[]`, `pros[]`, `cons[]`
- `reviewPlatforms[]` — `{platform, url, rating, reviewCount}` for Google Maps, Yelp, BBB, Angi, Facebook, YellowPages, MyMovingReviews. `rating`/`reviewCount` are only present on full-detail company-page records; listing-page records still carry the platform `url`.
- `movingServiceType: "longDistance"` — present only on records sourced from a long-distance/interstate-specialist listing (`byCity` with `serviceType=longDistance`, or `interstateMovers`); omitted on regular local-movers listings
- `companySlug`, `citySlug`, `stateSlug`, `detailLevel` (`full` or `summary`)
- `sourceUrl`, `recordType: "company"`, `scrapedAt`

### Output per city (mode = `stateCities`)

- `city`, `state`, `stateName`, `citySlug`, `stateSlug`
- `sourceUrl`, `recordType: "city"`, `scrapedAt`

### Output: city moving-cost estimate (mode = `byCity`, optional)

- `city`, `state`
- `costEstimatesBySize[]` — `{homeSize, crewSize, laborCostUsd, truckCostUsd, fullServiceCostUsd}` for Studio through 5+ Bedrooms
- `sourceUrl`, `recordType: "cityMovingCostEstimate"`, `scrapedAt`

### Output: interstate route info (mode = `interstateMovers`)

One extra summary record alongside the company records for that route:

- `fromState`, `toState`
- `distanceMiles` — real driving distance between the two states' representative cities
- `moversAnalyzedCount` — how many movers Great Guys Moving analyzed specifically for this route
- `nationwideMoversCount` — the site's total nationwide mover count, for context
- `lastModifiedDate`
- `sourceUrl`, `recordType: "interstateRouteInfo"`, `scrapedAt`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `topNational` | `topNational` / `byState` / `byCity` / `stateCities` / `companyDetail` / `interstateMovers` |
| `state` | string | – | US state, 2-letter code (mode=byState, byCity, stateCities, companyDetail) |
| `city` | string | – | City name, e.g. `New York City` (mode=byCity, companyDetail) |
| `fromState` | string | – | Origin US state, 2-letter code (mode=interstateMovers, required) |
| `toState` | string | – | Destination US state, 2-letter code (mode=interstateMovers, required) |
| `companySlug` | string | – | Company URL slug (mode=companyDetail, with state+city) |
| `companyUrl` | string | – | Full company page URL (mode=companyDetail, alternative to state+city+companySlug) |
| `fetchFullDetails` | boolean | `false` | mode=byCity: fetch full detail (11 sub-scores, USDOT, pros/cons) for every company, not just the top 10 |
| `serviceType` | string | `local` | mode=byCity: `local` (regular movers) or `longDistance` (interstate specialists for that city — a distinct company list) |
| `includeCityCostEstimate` | boolean | `true` | mode=byCity: also emit a city-level moving-cost-by-size record |
| `minScore` | int | – | Drop companies scoring below this (0-10) |
| `maxScore` | int | – | Drop companies scoring above this (0-10) |
| `minReviewCount` | int | – | Drop companies with fewer review data points |
| `ratingAdjective` | string | – | Keep only this rating tier |
| `usdotAuthorizedOnly` | boolean | `false` | Keep only USDOT-authorized companies |
| `maxItems` | int | `20` | Hard cap on returned records (1-500) |
| `proxyConfiguration` | object | – | Optional; only used as a fallback if the site starts blocking |

#### Example: top-ranked movers nationwide

```json
{
  "mode": "topNational",
  "maxItems": 5
}
````

#### Example: movers in a specific city

```json
{
  "mode": "byCity",
  "state": "NY",
  "city": "New York City",
  "maxItems": 30,
  "minScore": 8
}
```

#### Example: every city covered in a state

```json
{
  "mode": "stateCities",
  "state": "TX",
  "maxItems": 200
}
```

#### Example: single company lookup

```json
{
  "mode": "companyDetail",
  "companyUrl": "https://www.greatguysmove.com/companies/new-york/brooklyn/jp-urban-moving/"
}
```

#### Example: long-distance mover specialists in a city

```json
{
  "mode": "byCity",
  "state": "CA",
  "city": "Los Angeles",
  "serviceType": "longDistance",
  "maxItems": 20
}
```

#### Example: movers specializing in a state-to-state route

```json
{
  "mode": "interstateMovers",
  "fromState": "CA",
  "toState": "NY",
  "maxItems": 20
}
```

### Use cases

- **Moving-industry lead generation** — build a database of licensed movers by market
- **Consumer comparison tools** — power a "compare movers near me" feature with real scores and USDOT data
- **Compliance research** — cross-check USDOT authorization status for movers operating in a state
- **Market research** — analyze moving-cost benchmarks and competitive density by city
- **Franchise/expansion planning** — identify underserved cities or top competitors in a target market

### FAQ

**What is the data source?**
Great Guys Moving (greatguysmove.com), a third-party moving-company ranking site that analyzes millions of customer reviews and public USDOT/FMCSA licensing records. This actor is not affiliated with Great Guys Moving.

**What do the 11 quality sub-scores mean?**
Each is scored 0-10 based on analysis of customer reviews for that specific factor: overall quality, punctuality, affordability, communication, whether the company sticks to its quoted price, speed, friendliness, likelihood customers would hire them again, professionalism, conflict handling, and precision/care with belongings.

**Why do some companies have fewer fields than others?**
`detailLevel: "full"` records (the top-ranked companies shown on a state/city page, or any `companyDetail` lookup) carry the complete field set. `detailLevel: "summary"` records (companies beyond the top 10 on a city page, when `fetchFullDetails` is left off) only carry identity, address, score, and geo-coordinates — the source site doesn't expose full detail for every company on a listing page without visiting that company's own page. Set `fetchFullDetails: true` on `byCity` to fetch full detail for every company, at the cost of one extra request per company.

**Why don't all companies have an email, BBB rating, or state license number?**
The source only publishes these where it has verified data. A company without a confirmed USDOT number, state license, or BBB profile simply won't have those fields — this actor never fabricates placeholder values.

**Why do `reviewPlatforms` only appear on some records?**
The per-platform review breakdown (Google, Yelp, BBB, etc.) is only published on a company's own dedicated page, not on state/city listing pages. It appears whenever a record's `detailLevel` is `full` and the company's page happens to expose it.

**Why does a state or city's top-ranked list sometimes include a company whose address is in a different state or city?**
`byState` and `byCity` return Great Guys Moving's own "top movers for this market" ranking, which can include long-distance/interstate movers who serve that market without being headquartered there — this is the source site's own ranking behavior, not a scraping error. Each record's own `city`/`state`/`streetAddress` fields always reflect that company's actual registered address, so you can filter to strictly-local companies yourself if needed.

**How fresh is the data?**
Scores, review counts, and license data reflect whatever is live on greatguysmove.com at the time the actor runs. USDOT/FMCSA data includes its own `usdotLastUpdated` verification date from the source.

**Does this require a proxy or login?**
No. The `proxyConfiguration` input exists only as a safety-net fallback in case the source ever starts rate-limiting; leave it at its default and the actor works with zero configuration.

**Why does `usdotUrl` sometimes not load for automated tools?**
`usdotUrl` points to the official FMCSA SAFER government lookup page for that carrier's USDOT number. That government site applies its own bot protection which can block scripted/headless HTTP clients, even though the same link opens normally for a person browsing it directly. This is a characteristic of the federal government's own site, not a broken link from this actor.

**What's the difference between `byCity` with `serviceType=longDistance` and `interstateMovers`?**
`byCity` + `serviceType=longDistance` returns the long-distance/interstate mover specialists Great Guys Moving lists for one specific city (e.g. "long-distance movers in Los Angeles"). `interstateMovers` returns the movers Great Guys Moving ranks for one specific state-to-state route (e.g. "movers from California to New York"), plus a route-level record with the real driving distance and how many movers were analyzed for that route. Use `byCity` when you know the origin city; use `interstateMovers` when you only know the two states.

**Why do only some companies have `qualityFactorInsights`, `scoreHistory`, `email`, or `ratingBadgeImageUrl`?**
These come from the source's per-company review-analysis and rating-badge pipeline, which isn't run for every company in its database — only for companies with enough review volume/verification. When the source doesn't publish a value for a company, this actor omits the field entirely rather than sending a placeholder.

# Actor input Schema

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

What to fetch.

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

US state (mode=byState, byCity, stateCities, companyDetail).

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

City name, e.g. "New York City" or "Los Angeles" (mode=byCity, companyDetail). Must be paired with `state`.

## `fromState` (type: `string`):

Origin US state, 2-letter code (mode=interstateMovers, required).

## `toState` (type: `string`):

Destination US state, 2-letter code (mode=interstateMovers, required).

## `companySlug` (type: `string`):

Company URL slug, e.g. "jp-urban-moving" (mode=companyDetail). Found in a company's sourceUrl. Alternative to `companyUrl`.

## `companyUrl` (type: `string`):

Full company page URL, e.g. "https://www.greatguysmove.com/companies/new-york/brooklyn/jp-urban-moving/" (mode=companyDetail). Alternative to state+city+companySlug.

## `fetchFullDetails` (type: `boolean`):

mode=byCity only. When true, fetches the full detail page (11 quality sub-scores, USDOT data, pros/cons, review platforms) for every company up to `maxItems`, not just the top 10 shown on the city page. Slower (one extra request per company).

## `serviceType` (type: `string`):

mode=byCity only. "local" fetches the city's regular movers page; "longDistance" fetches the city's long-distance/interstate mover specialists page instead (a distinct company list). `fetchFullDetails` and `includeCityCostEstimate` are ignored when set to longDistance.

## `includeCityCostEstimate` (type: `boolean`):

mode=byCity only. When true, also emits one extra record with average local moving-cost estimates by home size for the city.

## `minScore` (type: `integer`):

Drop companies with an overall score below this (scale 0-10, e.g. 8).

## `maxScore` (type: `integer`):

Drop companies with an overall score above this (scale 0-10).

## `minReviewCount` (type: `integer`):

Drop companies with fewer than this many review data points.

## `ratingAdjective` (type: `string`):

Keep only companies whose rating tier matches exactly.

## `usdotAuthorizedOnly` (type: `boolean`):

Keep only companies whose USDOT operating status is "Authorized" for household goods or property.

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

Maximum number of records to return.

## `proxyConfiguration` (type: `object`):

Optional. Only used as a fallback if the site starts returning 403/429 from the datacenter IP.

## Actor input object example

```json
{
  "mode": "topNational",
  "state": "NY",
  "city": "New York City",
  "fromState": "CA",
  "toState": "NY",
  "fetchFullDetails": false,
  "serviceType": "local",
  "includeCityCostEstimate": true,
  "ratingAdjective": "",
  "usdotAuthorizedOnly": false,
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

Dataset containing all scraped moving companies, cities, and rankings.

# 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": "topNational",
    "state": "NY",
    "city": "New York City",
    "fromState": "CA",
    "toState": "NY",
    "fetchFullDetails": false,
    "serviceType": "local",
    "includeCityCostEstimate": true,
    "ratingAdjective": "",
    "usdotAuthorizedOnly": false,
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/greatguysmove-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": "topNational",
    "state": "NY",
    "city": "New York City",
    "fromState": "CA",
    "toState": "NY",
    "fetchFullDetails": False,
    "serviceType": "local",
    "includeCityCostEstimate": True,
    "ratingAdjective": "",
    "usdotAuthorizedOnly": False,
    "maxItems": 20,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/greatguysmove-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": "topNational",
  "state": "NY",
  "city": "New York City",
  "fromState": "CA",
  "toState": "NY",
  "fetchFullDetails": false,
  "serviceType": "local",
  "includeCityCostEstimate": true,
  "ratingAdjective": "",
  "usdotAuthorizedOnly": false,
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call crawlerbros/greatguysmove-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Great Guys Move Scraper",
        "description": "Scrape Great Guys Moving's algorithmic ranking of 24,000+ moving companies across the US. Get overall scores, 11 quality-factor sub-scores, USDOT/state license verification, review counts, pros/cons, and full contact details by state, city, or company.",
        "version": "1.0",
        "x-build-id": "MFhlIMtPS3HnjHdgt"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~greatguysmove-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-greatguysmove-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~greatguysmove-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-greatguysmove-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~greatguysmove-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-greatguysmove-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": "Mode",
                        "enum": [
                            "topNational",
                            "byState",
                            "byCity",
                            "stateCities",
                            "companyDetail",
                            "interstateMovers"
                        ],
                        "type": "string",
                        "description": "What to fetch.",
                        "default": "topNational"
                    },
                    "state": {
                        "title": "State",
                        "enum": [
                            "",
                            "AL",
                            "AK",
                            "AZ",
                            "AR",
                            "CA",
                            "CO",
                            "CT",
                            "DE",
                            "DC",
                            "FL",
                            "GA",
                            "HI",
                            "ID",
                            "IL",
                            "IN",
                            "IA",
                            "KS",
                            "KY",
                            "LA",
                            "ME",
                            "MD",
                            "MA",
                            "MI",
                            "MN",
                            "MS",
                            "MO",
                            "MT",
                            "NE",
                            "NV",
                            "NH",
                            "NJ",
                            "NM",
                            "NY",
                            "NC",
                            "ND",
                            "OH",
                            "OK",
                            "OR",
                            "PA",
                            "RI",
                            "SC",
                            "SD",
                            "TN",
                            "TX",
                            "UT",
                            "VT",
                            "VA",
                            "WA",
                            "WV",
                            "WI",
                            "WY"
                        ],
                        "type": "string",
                        "description": "US state (mode=byState, byCity, stateCities, companyDetail).",
                        "default": ""
                    },
                    "city": {
                        "title": "City",
                        "type": "string",
                        "description": "City name, e.g. \"New York City\" or \"Los Angeles\" (mode=byCity, companyDetail). Must be paired with `state`."
                    },
                    "fromState": {
                        "title": "From state",
                        "enum": [
                            "",
                            "AL",
                            "AK",
                            "AZ",
                            "AR",
                            "CA",
                            "CO",
                            "CT",
                            "DE",
                            "DC",
                            "FL",
                            "GA",
                            "HI",
                            "ID",
                            "IL",
                            "IN",
                            "IA",
                            "KS",
                            "KY",
                            "LA",
                            "ME",
                            "MD",
                            "MA",
                            "MI",
                            "MN",
                            "MS",
                            "MO",
                            "MT",
                            "NE",
                            "NV",
                            "NH",
                            "NJ",
                            "NM",
                            "NY",
                            "NC",
                            "ND",
                            "OH",
                            "OK",
                            "OR",
                            "PA",
                            "RI",
                            "SC",
                            "SD",
                            "TN",
                            "TX",
                            "UT",
                            "VT",
                            "VA",
                            "WA",
                            "WV",
                            "WI",
                            "WY"
                        ],
                        "type": "string",
                        "description": "Origin US state, 2-letter code (mode=interstateMovers, required).",
                        "default": ""
                    },
                    "toState": {
                        "title": "To state",
                        "enum": [
                            "",
                            "AL",
                            "AK",
                            "AZ",
                            "AR",
                            "CA",
                            "CO",
                            "CT",
                            "DE",
                            "DC",
                            "FL",
                            "GA",
                            "HI",
                            "ID",
                            "IL",
                            "IN",
                            "IA",
                            "KS",
                            "KY",
                            "LA",
                            "ME",
                            "MD",
                            "MA",
                            "MI",
                            "MN",
                            "MS",
                            "MO",
                            "MT",
                            "NE",
                            "NV",
                            "NH",
                            "NJ",
                            "NM",
                            "NY",
                            "NC",
                            "ND",
                            "OH",
                            "OK",
                            "OR",
                            "PA",
                            "RI",
                            "SC",
                            "SD",
                            "TN",
                            "TX",
                            "UT",
                            "VT",
                            "VA",
                            "WA",
                            "WV",
                            "WI",
                            "WY"
                        ],
                        "type": "string",
                        "description": "Destination US state, 2-letter code (mode=interstateMovers, required).",
                        "default": ""
                    },
                    "companySlug": {
                        "title": "Company slug",
                        "type": "string",
                        "description": "Company URL slug, e.g. \"jp-urban-moving\" (mode=companyDetail). Found in a company's sourceUrl. Alternative to `companyUrl`."
                    },
                    "companyUrl": {
                        "title": "Company URL",
                        "type": "string",
                        "description": "Full company page URL, e.g. \"https://www.greatguysmove.com/companies/new-york/brooklyn/jp-urban-moving/\" (mode=companyDetail). Alternative to state+city+companySlug."
                    },
                    "fetchFullDetails": {
                        "title": "Fetch full details for every company",
                        "type": "boolean",
                        "description": "mode=byCity only. When true, fetches the full detail page (11 quality sub-scores, USDOT data, pros/cons, review platforms) for every company up to `maxItems`, not just the top 10 shown on the city page. Slower (one extra request per company).",
                        "default": false
                    },
                    "serviceType": {
                        "title": "Service type",
                        "enum": [
                            "local",
                            "longDistance"
                        ],
                        "type": "string",
                        "description": "mode=byCity only. \"local\" fetches the city's regular movers page; \"longDistance\" fetches the city's long-distance/interstate mover specialists page instead (a distinct company list). `fetchFullDetails` and `includeCityCostEstimate` are ignored when set to longDistance.",
                        "default": "local"
                    },
                    "includeCityCostEstimate": {
                        "title": "Include city moving-cost estimate",
                        "type": "boolean",
                        "description": "mode=byCity only. When true, also emits one extra record with average local moving-cost estimates by home size for the city.",
                        "default": true
                    },
                    "minScore": {
                        "title": "Minimum score",
                        "minimum": 0,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Drop companies with an overall score below this (scale 0-10, e.g. 8)."
                    },
                    "maxScore": {
                        "title": "Maximum score",
                        "minimum": 0,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Drop companies with an overall score above this (scale 0-10)."
                    },
                    "minReviewCount": {
                        "title": "Minimum review data points",
                        "minimum": 0,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Drop companies with fewer than this many review data points."
                    },
                    "ratingAdjective": {
                        "title": "Rating tier",
                        "enum": [
                            "",
                            "Exceptional",
                            "Superb",
                            "Fabulous",
                            "Very Good",
                            "Good"
                        ],
                        "type": "string",
                        "description": "Keep only companies whose rating tier matches exactly.",
                        "default": ""
                    },
                    "usdotAuthorizedOnly": {
                        "title": "USDOT-authorized only",
                        "type": "boolean",
                        "description": "Keep only companies whose USDOT operating status is \"Authorized\" for household goods or property.",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of records to return.",
                        "default": 20
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional. Only used as a fallback if the site starts returning 403/429 from the datacenter IP."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
