# Boat Trader Scraper (`crawlerbros/boat-trader-scraper`) Actor

Scrape boattrader.com boat-for-sale listings - browse by type, class, make, condition, fuel, hull shape, US state, and price/year/length range, or fetch full listing detail by ID/URL.

- **URL**: https://apify.com/crawlerbros/boat-trader-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Automation, Developer tools, E-commerce
- **Stats:** 1 total users, 0 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

## Boat Trader Scraper

Scrape **Boat Trader** (boattrader.com) — one of the largest boat resale marketplaces in the US, listing new and used boats from private sellers and dealers nationwide. Browse by boat type, class, brand, condition, fuel type, hull shape, and US state, filter by price / model year / length, or fetch full listing detail for specific boats by ID or URL. No login, no cookies, no paid proxy required — an optional free datacenter proxy can be enabled for extra reliability.

### What this actor does

- **Two modes:** `browse` (filter-driven search) and `byId` (direct listing lookup)
- **Rich filter taxonomy:** boat type, boat class (88 sub-categories), boat group/activity, brand (100 curated + free-text override), condition, fuel type, hull shape, US state
- **Keyword search:** full-text keyword across title/description/equipment (matches Boat Trader's own site search — e.g. searching an engine brand returns boats powered by it, not just that brand of boat)
- **Range filters:** price, model year, and length (feet)
- **Full listing detail on lookup:** engines/horsepower, hull material, dealer contact, description, dimensions, images, video
- **Empty fields are omitted**

### Data source / limitations

Boat Trader's `robots.txt` disallows automated access to `/search-results/` and several query-string display parameters (`sort`, `PerPage`, `ViewType`, etc.). This actor never touches those paths — it exclusively uses the public `/boats/{filters}/` browse taxonomy and `/boat/{id}/` listing pages, both of which are open to crawling.

- Boat Trader's filter taxonomy (`/boats/type-X/class-Y/make-Z/state-W/...`) enforces a **fixed segment order** server-side; this actor always builds URLs in the verified valid order, and any filter combination the site itself rejects is reported as **zero matching listings** rather than silently substituting broader results.
- Price / model year / length filters are applied by the actor after fetching each results page, since Boat Trader's browse taxonomy does not expose numeric range segments natively. Very narrow combinations of taxonomy filters + range filters may scan a bounded number of upstream pages before giving up (matching typical real-world usage, not the entire multi-hundred-thousand-listing catalog).
- `boatGroup` (activity-based browsing, e.g. "Fishing Boats") is a separate taxonomy from `boatType`/`boatClass` on the live site and cannot be combined with them — setting `boatGroup` takes priority.
- Fields that only exist on the full listing page (engine specs, hull material, dealer contact detail, description, video) are populated in `mode=byId`; `mode=browse` returns the lighter field set available directly from the results page (still includes price, year, length, condition, dealer name, images, and location).
- This is an independent, third-party actor. It is not affiliated with, endorsed by, or supported by Boat Trader or Boats Group.

### Output per boat listing

- `boatId` — Boat Trader's numeric listing ID
- `title` — e.g. `2025 Bennington 22SSBSE`
- `make`, `model`, `year`
- `condition` — `new` or `used`
- `status` — listing status (e.g. `active`)
- `boatType` — `power` / `sail` / `pwc` / `small`
- `boatClass`, `secondaryClasses[]` — sub-category taxonomy (mode=byId enriches this)
- `fuelType` — `gasoline` / `diesel` / `electric` / `other`
- `hullMaterial`, `hullShape`, `hullKeelType`, `hin` (Hull Identification Number, mode=byId)
- `price`, `priceCurrency`, `priceDropAmount`, `priceHidden`
- `lengthFt`, `beamFt` (mode=byId), `seatingCapacity` (mode=byId)
- `engineCount`, `totalHorsepower`, `engineModels[]` (mode=byId)
- `locationCity`, `locationState`, `locationZip`, `locationCountry`, `latitude`, `longitude`
- `dealerName`, `dealerPhone`
- `isFsbo`, `isFinanceable` (mode=byId)
- `dateListed`, `dateModified` (mode=byId)
- `description`, `overview` (mode=byId)
- `images[]`, `primaryImageUrl`, `videoUrl`
- `listingUrl`, `sourceUrl`
- `recordType: "boatListing"`, `scrapedAt`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `browse` | `browse` (filter search) or `byId` (direct lookup) |
| `boatIds` | array | – | Listing IDs or URLs to fetch directly (mode=byId) |
| `boatType` | string | `power` | `power` / `sail` / `pwc` / `small` (mode=browse) |
| `boatClass` | string | – | Sub-category, e.g. `power-pontoon`, `sail-sloop` (mode=browse) |
| `boatGroup` | string | – | Activity-based category, e.g. `fishing-boats` — replaces `boatType`/`boatClass` (mode=browse) |
| `make` | string | – | Brand, from the top 100 most-listed brands (mode=browse) |
| `makeCustom` | string | – | Free-text brand for any brand not in `make` (mode=browse) |
| `condition` | string | – | `new` or `used` (mode=browse) |
| `fuelType` | string | – | `gas` / `diesel` / `electric` / `other` (mode=browse) |
| `hullShape` | string | – | Hull shape, e.g. `pontoon`, `deep-vee`, `catamaran` (mode=browse) |
| `state` | string | – | Two-letter US state code (mode=browse) |
| `keyword` | string | – | Full-text keyword search (mode=browse) |
| `minPrice` / `maxPrice` | int | – | Price range in USD |
| `minYear` / `maxYear` | int | – | Model year range |
| `minLengthFt` / `maxLengthFt` | int | – | Length range in feet |
| `maxItems` | int | `20` | Hard cap on emitted records (1–1000) |
| `proxyConfiguration` | object | off | Optional Apify proxy (free AUTO datacenter group); enable only if you see blocked/empty runs |

#### Example: browse new pontoon boats in Florida

```json
{
  "mode": "browse",
  "boatType": "power",
  "boatClass": "power-pontoon",
  "condition": "new",
  "state": "fl",
  "maxItems": 30
}
````

#### Example: used Sea Ray boats under $150,000

```json
{
  "mode": "browse",
  "make": "sea-ray",
  "condition": "used",
  "maxPrice": 150000,
  "maxItems": 25
}
```

#### Example: browse fishing boats 20–30 ft, built since 2015

```json
{
  "mode": "browse",
  "boatGroup": "fishing-boats",
  "minLengthFt": 20,
  "maxLengthFt": 30,
  "minYear": 2015,
  "maxItems": 25
}
```

#### Example: full listing detail lookup by ID/URL

```json
{
  "mode": "byId",
  "boatIds": [
    "9979385",
    "https://www.boattrader.com/boat/2011-regal-42-sport-coupe-9935643/"
  ]
}
```

### Use cases

- **Boat shoppers** — track new listings matching a brand, budget, and region
- **Dealership market research** — monitor competitor inventory and pricing by state
- **Marine industry analytics** — study price/length/year distributions across boat classes
- **Lead generation** — pull dealer contact info for outreach on newly listed boats
- **Price-tracking tools** — snapshot listings over time to detect price drops (`priceDropAmount`)

### FAQ

**What is the data source?**
Boat Trader (boattrader.com), one of the largest boat marketplaces in the United States, operated by Boats Group.

**Is this affiliated with Boat Trader?**
No. This is an independent third-party actor that reads Boat Trader's publicly accessible browse and listing pages.

**Why do some listings have fewer fields than others?**
`mode=browse` returns the fields available on the results page (price, year, length, condition, dealer, images, location). `mode=byId` fetches the full listing page and includes additional detail (engine specs, hull material, description, dealer phone detail, video).

**Why is `price` sometimes missing?**
Some dealers mark their listing "Call for price" (`priceHidden: true`); in that case no numeric price is published by Boat Trader, so none is returned.

**Can I combine `boatGroup` with `boatType`?**
No — on the live site these are mutually exclusive taxonomies. If `boatGroup` is set, it takes priority and `boatType`/`boatClass` are ignored.

**Can I search across all 50 states at once?**
Yes — leave `state` blank to search nationwide (the default).

**How fresh is the data?**
Every run fetches Boat Trader's live pages at request time; there is no caching.

**Does this actor need a proxy or login?**
No. It loads Boat Trader's free/public pages directly — no cookies, no API key, no paid proxy group required. An optional free Apify (AUTO) datacenter proxy can be turned on in the input if you ever see empty runs from your IP.

# Actor input Schema

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

What to fetch.

## `boatIds` (type: `array`):

Boat Trader listing IDs (e.g. `9979385`) or full listing URLs (e.g. `https://www.boattrader.com/boat/2025-bennington-22ssbse-9979385/`).

## `boatType` (type: `string`):

Top-level Boat Trader taxonomy. Leave blank to browse all types (or use Boat group instead).

## `boatClass` (type: `string`):

Sub-category within Boat type (e.g. Pontoon, Center Console, Sloop). Must match the selected Boat type's family (power-*/sail-*/unpowered-\*) or it is ignored.

## `boatGroup` (type: `string`):

Alternative activity-based taxonomy (fishing, cruising, watersports, etc). When set, this replaces Boat type / Boat class (Boat Trader treats them as mutually exclusive).

## `make` (type: `string`):

Top 100 most-listed brands on Boat Trader. For any other brand, leave this blank and use `makeCustom` instead.

## `makeCustom` (type: `string`):

Free-text brand name for makes not in the `make` dropdown (e.g. `Marex`, `Axopar`). Overrides `make` when set.

## `condition` (type: `string`):

New or used boats.

## `fuelType` (type: `string`):

Engine fuel type.

## `hullShape` (type: `string`):

Hull shape / configuration.

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

Restrict results to listings located in this US state.

## `keyword` (type: `string`):

Full-text keyword search across title, description, and equipment (e.g. engine brand) — matches Boat Trader's own site search. Combines with other filters above.

## `minPrice` (type: `integer`):

Drop listings priced below this amount.

## `maxPrice` (type: `integer`):

Drop listings priced above this amount.

## `minYear` (type: `integer`):

Drop listings older than this model year.

## `maxYear` (type: `integer`):

Drop listings newer than this model year.

## `minLengthFt` (type: `integer`):

Drop boats shorter than this length in feet.

## `maxLengthFt` (type: `integer`):

Drop boats longer than this length in feet.

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

Hard cap on emitted records.

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

Optional Apify proxy. Boat Trader is usually reachable without it; enable the free AUTO datacenter group if you see blocked/empty runs from your IP.

## Actor input object example

```json
{
  "mode": "browse",
  "boatIds": [],
  "boatType": "power",
  "boatClass": "",
  "boatGroup": "",
  "make": "",
  "condition": "",
  "fuelType": "",
  "hullShape": "",
  "state": "",
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `boats` (type: `string`):

Dataset containing all scraped Boat Trader listings.

# 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": "browse",
    "boatIds": [],
    "boatType": "power",
    "boatClass": "",
    "boatGroup": "",
    "make": "",
    "condition": "",
    "fuelType": "",
    "hullShape": "",
    "state": "",
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/boat-trader-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": "browse",
    "boatIds": [],
    "boatType": "power",
    "boatClass": "",
    "boatGroup": "",
    "make": "",
    "condition": "",
    "fuelType": "",
    "hullShape": "",
    "state": "",
    "maxItems": 20,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/boat-trader-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": "browse",
  "boatIds": [],
  "boatType": "power",
  "boatClass": "",
  "boatGroup": "",
  "make": "",
  "condition": "",
  "fuelType": "",
  "hullShape": "",
  "state": "",
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call crawlerbros/boat-trader-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Boat Trader Scraper",
        "description": "Scrape boattrader.com boat-for-sale listings - browse by type, class, make, condition, fuel, hull shape, US state, and price/year/length range, or fetch full listing detail by ID/URL.",
        "version": "1.0",
        "x-build-id": "iWy0ZNov2ovgawx9n"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~boat-trader-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-boat-trader-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~boat-trader-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-boat-trader-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~boat-trader-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-boat-trader-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": [
                            "browse",
                            "byId"
                        ],
                        "type": "string",
                        "description": "What to fetch.",
                        "default": "browse"
                    },
                    "boatIds": {
                        "title": "Boat IDs or URLs (mode=byId)",
                        "type": "array",
                        "description": "Boat Trader listing IDs (e.g. `9979385`) or full listing URLs (e.g. `https://www.boattrader.com/boat/2025-bennington-22ssbse-9979385/`).",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "boatType": {
                        "title": "Boat type (mode=browse)",
                        "enum": [
                            "",
                            "power",
                            "sail",
                            "pwc",
                            "small"
                        ],
                        "type": "string",
                        "description": "Top-level Boat Trader taxonomy. Leave blank to browse all types (or use Boat group instead).",
                        "default": "power"
                    },
                    "boatClass": {
                        "title": "Boat class (mode=browse)",
                        "enum": [
                            "",
                            "power-pwc",
                            "power-aft",
                            "power-airboat",
                            "power-aluminum",
                            "power-antique",
                            "power-barge",
                            "power-bass",
                            "power-bay",
                            "power-bowrider",
                            "power-center",
                            "power-commercial",
                            "power-convertible",
                            "power-crossover",
                            "power-cruiseship",
                            "power-cruiser",
                            "power-cuddy",
                            "power-deck",
                            "power-dive",
                            "power-downeast",
                            "power-dragger",
                            "power-dualconsole",
                            "power-expeditionyacht",
                            "power-expresscruiser",
                            "power-flats",
                            "power-flybridge",
                            "power-fresh",
                            "power-highperf",
                            "power-house",
                            "power-jet",
                            "power-jon",
                            "power-lobster",
                            "power-mega",
                            "power-motor",
                            "power-motorsailer",
                            "power-multihull",
                            "power-other",
                            "power-passenger",
                            "power-pilot",
                            "power-pontoon",
                            "power-pcatamaran",
                            "power-rivercruiser",
                            "power-runabout",
                            "power-saltfish",
                            "power-skifish",
                            "power-skiwake",
                            "power-skiff",
                            "power-sloop",
                            "power-sportfish",
                            "power-sportcruiser",
                            "power-surfboat",
                            "power-trawler",
                            "power-troller",
                            "power-tug",
                            "power-unspec",
                            "power-util",
                            "power-walk",
                            "sail-antique",
                            "sail-barge",
                            "sail-beachcat",
                            "sail-catamaran",
                            "sail-centercockpit",
                            "sail-commercial",
                            "sail-cruiser",
                            "sail-cutter",
                            "sail-day",
                            "sail-deck",
                            "sail-ketch",
                            "sail-motor",
                            "sail-multihull",
                            "sail-other",
                            "sail-performance",
                            "sail-pilot",
                            "sail-racercruiser",
                            "sail-racer",
                            "sail-schooner",
                            "sail-sloop",
                            "sail-trimaran",
                            "sail-unspec",
                            "sail-yawl",
                            "unpowered-kayak",
                            "power-dinghy",
                            "sail-dinghy",
                            "unpowered-dinghy",
                            "power-inflatable",
                            "power-narrow",
                            "power-rib",
                            "power-tender",
                            "unpowered-tender"
                        ],
                        "type": "string",
                        "description": "Sub-category within Boat type (e.g. Pontoon, Center Console, Sloop). Must match the selected Boat type's family (power-*/sail-*/unpowered-*) or it is ignored.",
                        "default": ""
                    },
                    "boatGroup": {
                        "title": "Boat group / activity (mode=browse)",
                        "enum": [
                            "",
                            "fishing-boats",
                            "day-cruising-boats",
                            "overnight-cruising-boats",
                            "long-range-cruising-boats",
                            "lakes-and-rivers-boats",
                            "sailing-boats",
                            "watersports",
                            "commercial-boats"
                        ],
                        "type": "string",
                        "description": "Alternative activity-based taxonomy (fishing, cruising, watersports, etc). When set, this replaces Boat type / Boat class (Boat Trader treats them as mutually exclusive).",
                        "default": ""
                    },
                    "make": {
                        "title": "Make / brand (mode=browse)",
                        "enum": [
                            "",
                            "tracker",
                            "sea-ray",
                            "sun-tracker",
                            "yamaha-boats",
                            "sea-doo",
                            "ranger",
                            "bennington",
                            "boston-whaler",
                            "other",
                            "chaparral",
                            "regal",
                            "bayliner",
                            "yamaha-waverunner",
                            "grady-white",
                            "tahoe",
                            "cobalt",
                            "barletta",
                            "starcraft",
                            "robalo",
                            "tidewater",
                            "lowe",
                            "nitro",
                            "g3",
                            "avalon",
                            "beneteau",
                            "key-west",
                            "mastercraft",
                            "sea-hunt",
                            "sportsman",
                            "lund",
                            "pursuit",
                            "nautique",
                            "harris",
                            "sea-pro",
                            "sylvan",
                            "mako",
                            "scout",
                            "malibu",
                            "formula",
                            "crownline",
                            "highfield",
                            "monterey",
                            "chris-craft",
                            "godfrey",
                            "skeeter",
                            "four-winns",
                            "wellcraft",
                            "sea-fox",
                            "cobia",
                            "cruisers-yachts",
                            "xpress",
                            "jeanneau",
                            "tiara-yachts",
                            "hurricane",
                            "carver",
                            "stingray",
                            "carolina-skiff",
                            "custom",
                            "suncatcher",
                            "catalina",
                            "bentley-pontoons",
                            "nauticstar",
                            "veranda",
                            "crestliner",
                            "everglades",
                            "tig",
                            "parker",
                            "hunter",
                            "viaggio",
                            "crest",
                            "azimut",
                            "pathfinder",
                            "premier",
                            "world-cat",
                            "regulator",
                            "vexus",
                            "scarab",
                            "edgewater",
                            "axopar",
                            "contender",
                            "vision-marine-technologies",
                            "rinker",
                            "sailfish",
                            "hatteras",
                            "shoalwater",
                            "edge-duck-boats",
                            "silverton",
                            "blackfin",
                            "supra",
                            "triton",
                            "caymas",
                            "viking",
                            "fountain",
                            "manitou",
                            "evotti",
                            "alumacraft",
                            "axis",
                            "regency",
                            "yellowfin",
                            "zodiac"
                        ],
                        "type": "string",
                        "description": "Top 100 most-listed brands on Boat Trader. For any other brand, leave this blank and use `makeCustom` instead.",
                        "default": ""
                    },
                    "makeCustom": {
                        "title": "Custom make / brand (mode=browse)",
                        "type": "string",
                        "description": "Free-text brand name for makes not in the `make` dropdown (e.g. `Marex`, `Axopar`). Overrides `make` when set."
                    },
                    "condition": {
                        "title": "Condition (mode=browse)",
                        "enum": [
                            "",
                            "new",
                            "used"
                        ],
                        "type": "string",
                        "description": "New or used boats.",
                        "default": ""
                    },
                    "fuelType": {
                        "title": "Fuel type (mode=browse)",
                        "enum": [
                            "",
                            "gas",
                            "diesel",
                            "electric",
                            "other"
                        ],
                        "type": "string",
                        "description": "Engine fuel type.",
                        "default": ""
                    },
                    "hullShape": {
                        "title": "Hull shape (mode=browse)",
                        "enum": [
                            "",
                            "modified-vee",
                            "deep-vee",
                            "pontoon",
                            "other",
                            "flat",
                            "monohull",
                            "catamaran",
                            "displacement",
                            "semi-displacement",
                            "rib",
                            "planing",
                            "sea-v2",
                            "tunnel",
                            "trimaran",
                            "roll-up",
                            "foldable"
                        ],
                        "type": "string",
                        "description": "Hull shape / configuration.",
                        "default": ""
                    },
                    "state": {
                        "title": "US state (mode=browse)",
                        "enum": [
                            "",
                            "AK",
                            "AL",
                            "AR",
                            "AZ",
                            "CA",
                            "CO",
                            "CT",
                            "DC",
                            "DE",
                            "FL",
                            "GA",
                            "HI",
                            "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": "Restrict results to listings located in this US state.",
                        "default": ""
                    },
                    "keyword": {
                        "title": "Keyword (mode=browse)",
                        "type": "string",
                        "description": "Full-text keyword search across title, description, and equipment (e.g. engine brand) — matches Boat Trader's own site search. Combines with other filters above."
                    },
                    "minPrice": {
                        "title": "Min price (USD)",
                        "minimum": 0,
                        "maximum": 100000000,
                        "type": "integer",
                        "description": "Drop listings priced below this amount."
                    },
                    "maxPrice": {
                        "title": "Max price (USD)",
                        "minimum": 0,
                        "maximum": 100000000,
                        "type": "integer",
                        "description": "Drop listings priced above this amount."
                    },
                    "minYear": {
                        "title": "Min model year",
                        "minimum": 1900,
                        "maximum": 2100,
                        "type": "integer",
                        "description": "Drop listings older than this model year."
                    },
                    "maxYear": {
                        "title": "Max model year",
                        "minimum": 1900,
                        "maximum": 2100,
                        "type": "integer",
                        "description": "Drop listings newer than this model year."
                    },
                    "minLengthFt": {
                        "title": "Min length (ft)",
                        "minimum": 0,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Drop boats shorter than this length in feet."
                    },
                    "maxLengthFt": {
                        "title": "Max length (ft)",
                        "minimum": 0,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Drop boats longer than this length in feet."
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Hard cap on emitted records.",
                        "default": 20
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional Apify proxy. Boat Trader is usually reachable without it; enable the free AUTO datacenter group if you see blocked/empty runs from your IP.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
