# Boat Trader Scraper $1.3/1K💰 | Boat Listings | Dealer Data (`ahmed_jasarevic/boattrader-scraper`) Actor

Scrape Boat Trader — America's largest boat marketplace — for complete new and used boat listings and the full dealer directory. Track boat prices, research used boat values, build marine market intelligence. Only $1.30 per 1,000 results.

- **URL**: https://apify.com/ahmed\_jasarevic/boattrader-scraper.md
- **Developed by:** [Ahmed Jasarevic](https://apify.com/ahmed_jasarevic) (community)
- **Categories:** E-commerce, Lead generation, Agents
- **Stats:** 1 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.27 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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 — Boat Listings & Dealer Directory Data

Extract complete Boat Trader boat listings — price, year, make, model, location and dealer — plus the full dealer directory with phones, from America's largest boat marketplace, at **$1.30 per 1,000 results**, the lowest verified price for Boat Trader data.

### Main Use Cases

- **Boat price tracking & monitoring** — collect listing prices and watch the market over time with scheduled runs
- **Used boat values & valuation research** — build real-time active-listing comps, the same method Boat Trader's own Price Checker uses, for fair-market pricing research
- **Marine market research** — analyze inventory, makes, models, and price levels across regions and dealers
- **Boat dealer database & lead generation** — extract the full Boat Trader dealer directory: dealer name, address, city, state, phone, logo, and profile URL
- **Boat inventory data for analytics** — feed structured new and used boat listings into dashboards, spreadsheets, and market reports

### How It Works

The actor launches a full headless Chrome browser, opens your start URLs on boattrader.com and walks the public browse pages (`/boats/`, `/boats/page-N/`) exactly like a normal visitor. It reads the listing cards on each page and pushes one structured JSON record per listing to the default dataset. Start URLs that contain `/boat-dealers/` are detected automatically and their records go to a **separate `dealers` dataset** instead.

It scrapes three pages concurrently, deduplicates by listing ID, and stops when — whichever comes first — `maxItems` is reached, two consecutive pages return no listings, or the results wrap (the first listing of a page matches the very first listing seen). If a page returns a bot-challenge page, the actor retries once with a fresh browser session.

### Scrape Boat Listings For Price Tracking

The input is a standard Apify actor input object:

| Field | Type | Required | Default | Notes |
|---|---|---|---|---|
| `startUrls` | `array` of `{ url }` | Yes\* | `https://www.boattrader.com/boats/` | Any Boat Trader browse URL. URLs containing `/boat-dealers/` produce dealer records (separate `dealers` dataset). \*Required in the schema; if omitted, the actor falls back to the default boats catalog. |
| `maxItems` | `integer` | No | `0` (no limit) | Maximum number of listings to scrape across all pages. Set a value to cap cost on large catalog runs. |
| `sort` | `string` | No | `recommended-desc` | Accepted for forward compatibility; not applied by the current build. |
| `distance` | `string` | No | `25mi` | Accepted for forward compatibility; not applied by the current build. |

### Boat Listing & Dealer Data Fields

Each record in the default (boats) dataset contains:

`id`, `category` (`"boat"` or `"dealer"`), `title`, `year`, `make`, `model`, `type`, `boatClass`, `condition`, `price`, `discountPrice`, `priceHidden`, `length` (ft), `state`, `city`, `country`, `zip`, `distanceToFilteredLocation`, `dealerName`, `dealerRootName`, `dealerId`, `dealerLogo`, `contact`, `images`, `address`, `phone`, `listingPrice`, `portalLink`, `url`

**Populated from browse pages:** `id`, `category`, `title`, `year`, `make`, `model`, `listingPrice` (parsed from the visible price text; `null` for "call for price"/POA listings), `state`, `city`, `country`, `zip`, `dealerName`, `dealerLogo`, `images`, `portalLink`, `url`.

**Reserved, currently always `null`/`false` in this build:** `type`, `boatClass`, `condition`, `price`, `discountPrice`, `priceHidden` (`false`), `length`, `distanceToFilteredLocation`, `dealerRootName`, `dealerId` (boats), `contact`, `address` (boats), `phone` (boats) — the browse-card extraction does not open individual detail pages in this build. Use `listingPrice` for prices.

Dealer records (in the `dealers` dataset) are populated with: `id`, `category` (`"dealer"`), `title` (dealer name), `dealerName`, `dealerId`, `dealerLogo`, `address`, `city`, `state`, `zip`, `phone` (from the call-now link), `images`, `url`. Year/make/model/price fields are `null` for dealer rows.

### Example Input

Run this to scrape the default boats catalog with a cost cap:

```json
{
  "startUrls": [
    { "url": "https://www.boattrader.com/boats/" }
  ],
  "maxItems": 100
}
```

Run this to build a dealer directory:

```json
{
  "startUrls": [
    { "url": "https://www.boattrader.com/boat-dealers/" }
  ],
  "maxItems": 50
}
```

### Example Output

Boat listing (default dataset):

```json
{
  "id": "13041234",
  "category": "boat",
  "title": "2020 Sea Ray Sundancer 320",
  "year": 2020,
  "make": "Sea Ray",
  "model": "Sundancer 320",
  "state": "FL",
  "city": "Fort Lauderdale",
  "country": "US",
  "zip": "33316",
  "dealerName": "MarineMax",
  "dealerLogo": "https://media.boattrader.com/images/dealer-logo.png",
  "images": ["https://media.boattrader.com/images/photo1.jpg"],
  "listingPrice": 249900,
  "portalLink": "https://www.boattrader.com/boats-for-sale/boat/13041234/2020-Sea-Ray-Sundancer-320",
  "url": "https://www.boattrader.com/boats-for-sale/boat/13041234/2020-Sea-Ray-Sundancer-320",
  "type": null,
  "boatClass": null,
  "condition": null,
  "price": null,
  "discountPrice": null,
  "priceHidden": false,
  "length": null,
  "distanceToFilteredLocation": null,
  "dealerRootName": null,
  "dealerId": null,
  "contact": null,
  "address": null,
  "phone": null
}
```

Dealer record (`dealers` dataset):

```json
{
  "id": "987654",
  "category": "dealer",
  "title": "MarineMax Fort Lauderdale",
  "dealerName": "MarineMax Fort Lauderdale",
  "dealerId": "987654",
  "dealerLogo": "https://media.boattrader.com/images/dealer-logo.png",
  "address": "4550 Anglers Ave, Fort Lauderdale, FL",
  "city": "Fort Lauderdale",
  "state": "FL",
  "phone": "+1 954-555-0134",
  "images": ["https://media.boattrader.com/images/dealer-logo.png"],
  "url": "https://www.boattrader.com/boat-dealers/987654/marinemax-fort-lauderdale",
  "year": null,
  "make": null,
  "model": null,
  "price": null,
  "condition": null,
  "listingPrice": null
}
```

### Automate Boat Price Monitoring With Schedules And Integrations

Any Apify actor can be scheduled and piped into the rest of your stack:

- **Schedule it** — run weekly for price tracking, or daily to catch price drops early
- **REST API** — call it programmatically from your own app or an AI agent with a simple `POST` to the Apify API
- **Webhooks** — get notified when each run finishes and forward the dataset to your service
- **Zapier / Make** — connect Boat Trader data to Google Sheets, Slack, Airtable, or your CRM via Apify's official integrations

### Related Marine Market Scrapers

- **[YachtWorld Scraper](https://apify.com/crawlerbros/yachtworld-scraper)** — the world's largest yacht and boat marketplace; broker-heavy inventory on a global scale (7 users, 4 monthly — most active marine actor)
- **[YATCO Scraper](https://apify.com/parseforge/yatco-scraper)** — US yacht listings with specifications, pricing, and broker details (28 users — largest marine actor)
- **[Boat24 Scraper & Market Intelligence](https://apify.com/marielise.dev/boat24-scraper-intelligence)** — Europe's largest boat marketplace with built-in valuation reports (14 users)
- **[Boat Trader Scraper (crawlerbros)](https://apify.com/crawlerbros/boat-trader-scraper)** — another Boat Trader scraper with per-listing dealer contact data (4 users, 5.00★)
- **[ApolloDuck Scraper & Market Intelligence](https://apify.com/marielise.dev/apolloduck-scraper-intelligence)** — UK/Europe boats, barges, and narrowboats (6 users)

### Boat Trader Scraper FAQ

#### Is there a Boat Trader official API?

No. Boat Trader does not publish a public API for listing data. The standard, documented way to get structured Boat Trader data is reading the public browse pages — which is exactly what this actor does. This actor is the **Boat Trader API alternative** for apps and agents that need the data programmatically.

#### How much is my boat worth?

The most accurate, current method is comparing real-time active listings — the same approach Boat Trader's own Boat Price Checker uses. With this actor you can collect every comparable listing (year, make, model, location, asking price) from the whole catalog and compute current market value or price-per-foot yourself. Guide-book baselines (JD Power/NADA, ABOS Marine Blue Book) are useful for older boats, but they lag the market.

#### How is this different from scraping YachtWorld?

Boat Trader is the largest boat marketplace in America, heavy on dealer inventory and private sellers, and it exposes the full **dealer directory** — a unique data source. YachtWorld (covered, for example, by the [crawlerbros YachtWorld Scraper](https://apify.com/crawlerbros/yachtworld-scraper)) is the world's largest yacht and boat marketplace, more broker- and yacht-focused and more global. Scrape both for a complete marine market picture.

#### How do I build a boat dealer database?

Run the actor on `https://www.boattrader.com/boat-dealers/` and every dealer on the browse pages lands in the separate `dealers` dataset with dealer name, address, city, state, ZIP, phone, logo, and profile URL. This is the low-cost alternative to paid boat-dealer databases (commercial products selling 8,000–40,000 dealer records at $27–$299).

#### How often should I track boat prices?

Boats sit on the market far longer than cars, so **weekly** is a solid default for price tracking; **daily** is only worth it when you monitor specific fast-moving models or a particular dealer's inventory. Because runs are cheap (pay per result), a weekly catalog snapshot costs little.

#### Is scraping Boat Trader legal?

This actor reads only publicly accessible pages — it does not log in, bypass paywalls, or solve CAPTCHAs. You are responsible for respecting Boat Trader's Terms of Service and `robots.txt` and for how you use the data.

### Why Use This Scraper — Verified Comparison

| Capability | Other Boat Trader scrapers | This actor |
|---|---|---|
| Price per 1,000 results | $2.00 (jungle\_synthesizer) — $2.80 (solidcode) — $4.33 (crawlerbros) — $5.00 (lulzasaur) | **$1.30** |
| Full dealer directory (name, address, phone, logo, profile URL) | Not offered — dealer contact only per listing | **Yes — dedicated `dealers` dataset** |
| Whole-catalog pagination from any start URL | Varies | Yes (3 pages concurrently, deduplicated) |
| `listingPrice` parsed from every card | Varies | Yes — numeric or `null` for POA/call-for-price |
| Actor start cost | $0.005–$0.10 per event | **$0.0005 per event** |

### SEO Keywords

boat trader scraper, boattrader scraper, boat listings scraper, scrape boat listings, boat price tracker, track boat prices, boat price monitoring, used boat values, boat valuation data, boat market data, marine market research, boat dealer list, boat dealer database, boat dealer leads, boat dealer directory, boat inventory data, boats for sale data, new and used boat listings, boat trader api, boattrader api alternative, yachtworld alternative, boat price per foot, boat depreciation data, boat market analysis

### For AI Agents & LLM Apps

**Purpose:** returns structured Boat Trader boat listing records (catalog pages) and, for `/boat-dealers/` start URLs, dealer-directory records — as JSON. Boats go to the run's default dataset; dealers go to a separate dataset named `dealers`.

**Minimal working input:**

```json
{
  "startUrls": [{ "url": "https://www.boattrader.com/boats/" }],
  "maxItems": 50
}
```

`startUrls` may be omitted entirely (the actor then defaults to `https://www.boattrader.com/boats/`). `maxItems` defaults to `0` = **no limit** — a cost-aware agent should always set it.

**Output fields:** `id`, `category` (`"boat"`/`"dealer"`), `title`, `year`, `make`, `model`, `state`, `city`, `country`, `zip`, `dealerName`, `dealerLogo`, `images`, `listingPrice`, `portalLink`, `url`, plus reserved `null` fields (`type`, `boatClass`, `condition`, `price`, `discountPrice`, `priceHidden: false`, `length`, `distanceToFilteredLocation`, `dealerRootName`, `dealerId`, `contact`, `address`, `phone` — note the browse-card build does not populate the structured `price`; use `listingPrice`).

**Behaviors an agent should know:**

- **Mode routing:** start URLs containing `/boat-dealers/` switch the run to dealer-directory mode → records land in a separate dataset named `dealers`, and boat fields (`year`, `make`, `model`, `price`, `listingPrice`) come back `null`. Non-dealer URLs → boat records in the default dataset. Do not mix both kinds of URLs in one run if you want them in the same dataset.
- **Stop conditions:** run ends when `maxItems` is hit, after 2 consecutive empty pages, or when the catalog wraps. It does not crawl the entire site; it walks numbered browse pages from your start URL.
- **Cost/billing:** pay per result — $0.0013 per record in the default dataset, plus a $0.0005 per-GB start fee. Set `maxItems` to bound spend.
- **Pricing:** use `listingPrice` (parsed numeric) — the structured `price` field is always `null` in this build.

### Legal & Compliance Disclaimer

This actor is an independent project and is **not affiliated with, endorsed by, or sponsored by Boat Trader** (Trader Interactive). It accesses only publicly available boattrader.com pages — no login, no CAPTCHA solving, no paid-content bypass. Users are responsible for complying with Boat Trader's Terms of Service and applicable data-protection laws (including GDPR/CCPA where EU/California data is involved) and for how they use the data. The `dealers` dataset contains business contact data (dealer names, addresses, phone numbers); do not use it for unsolicited commercial outreach in violation of applicable law (e.g. CAN-SPAM, TCPA).

# Actor input Schema

## `startUrls` (type: `array`):

Boattrader.com URLs to scrape from. Paste any search or listing page URL.

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

Maximum number of boats to scrape across all pages (0 = no limit).

## `sort` (type: `string`):

Sort order for results.

## `distance` (type: `string`):

Distance filter for location-based searches (e.g. 25mi, 50mi, 100mi). Leave empty for no filter.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.boattrader.com/boats/"
    }
  ],
  "maxItems": 10,
  "sort": "recommended-desc",
  "distance": "25mi"
}
```

# Actor output Schema

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

No description

## `dealers` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "startUrls": [
        {
            "url": "https://www.boattrader.com/boats/"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("ahmed_jasarevic/boattrader-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 = { "startUrls": [{ "url": "https://www.boattrader.com/boats/" }] }

# Run the Actor and wait for it to finish
run = client.actor("ahmed_jasarevic/boattrader-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "startUrls": [
    {
      "url": "https://www.boattrader.com/boats/"
    }
  ]
}' |
apify call ahmed_jasarevic/boattrader-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,ahmed_jasarevic/boattrader-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/R9cF05WF23lUqizq3/builds/LUvLHH7YU1DOfSdt5/openapi.json