# Boat Charter Scraper - Boatsetter & GetMyBoat (`crawlerbros/boat-charter-scraper`) Actor

Scrape boat rental and charter listings from Boatsetter and GetMyBoat - titles, boat type, capacity, hourly/daily price, captain availability, ratings, photos, and booking URLs for any destination worldwide.

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

## Boat Charter Scraper — Boatsetter & GetMyBoat

Scrape **boat rental and charter listings** from Boatsetter and GetMyBoat, the two largest peer-to-peer boat rental marketplaces. Search any destination worldwide and get listing titles, boat type, guest capacity, hourly pricing, captain availability, ratings, photos, and direct booking links — merged from one or both platforms in a single run. HTTP-only, no login, no cookies required.

### What this actor does

- **Two platforms in one actor:** search Boatsetter, GetMyBoat, or both at once (results are tagged with their source platform)
- **Destination search:** any city, region, lake, or marina worldwide
- **Boat type filter:** powerboat, yacht, sailboat, pontoon, fishing boat/charter, houseboat, jet ski
- **Capacity, price range, and captain-included filters**
- **Sort by relevance, price, or rating**
- **Empty fields are omitted** from every record — you won't see `null` or blank strings

### Output per listing

- `id` — platform-specific listing ID
- `platform` — `boatsetter` or `getmyboat`
- `title` — listing headline
- `location` — city/region/country text
- `boatType` — the platform's own category name (e.g. "Powerboats", "Flybridge")
- `capacity` — max number of guests
- `priceAmount`, `priceUnit`, `priceCurrency`, `priceDisplay` — starting price (usually per hour)
- `priceMaxAmount` — top of the listed price range, when the platform shows one
- `captainIncluded` — `true`/`false` when the platform states it clearly
- `captainOption` — the platform's raw captain-option text
- `rating`, `reviewCount`, `totalBookings`
- `superOwner` — top-rated/verified-owner badge
- `instantBook` — instant-booking available
- `imageUrl` — listing photo
- `listingUrl` — direct link to the listing on the source platform
- `description` — listing description (HTML stripped)
- `make`, `model`, `yearManufactured`, `lengthFeet` — boat specs (Boatsetter only, when published)
- `latitude`, `longitude`
- `recordType: "boatListing"`, `scrapedAt`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `location` | string | `Miami, FL` | **Required.** Destination, e.g. `"Miami, FL"`, `"Lake Tahoe"`, `"Sydney, Australia"` |
| `platform` | string | `both` | `both` / `boatsetter` / `getmyboat` |
| `boatType` | string | `any` | `any` / `powerboat` / `yacht` / `sailboat` / `pontoon` / `fishing` / `houseboat` / `jetski` |
| `tripDate` | string | one week out | Trip date `YYYY-MM-DD`; affects live pricing/availability |
| `minCapacity` | int | – | Minimum guest capacity |
| `captainOption` | string | `any` | `any` / `captained` / `bareboat` |
| `priceMinPerHour` | int | – | Minimum hourly price (USD) |
| `priceMaxPerHour` | int | – | Maximum hourly price (USD) |
| `sortBy` | string | `relevance` | `relevance` / `priceAsc` / `priceDesc` / `ratingDesc` |
| `maxItems` | int | `30` | Max listings to return (1–500) |
| `proxyConfiguration` | object | off | Optional Apify Proxy; both sites are public and don't require it |

#### Example: yachts in Miami with a captain included

```json
{
  "location": "Miami, FL",
  "platform": "both",
  "boatType": "yacht",
  "captainOption": "captained",
  "maxItems": 25
}
````

#### Example: budget pontoon boats on GetMyBoat only

```json
{
  "location": "Lake Travis, TX",
  "platform": "getmyboat",
  "boatType": "pontoon",
  "priceMaxPerHour": 150,
  "sortBy": "priceAsc"
}
```

#### Example: highest-rated sailboats for 8+ guests

```json
{
  "location": "San Diego, CA",
  "boatType": "sailboat",
  "minCapacity": 8,
  "sortBy": "ratingDesc"
}
```

### Use cases

- **Marine tourism research** — compare charter prices and availability across destinations
- **Boat charter brokers** — monitor competitor pricing and fleet mix in a market
- **Travel content & itinerary planning** — surface real, bookable boat experiences for a destination guide
- **Market analysis** — track boat type mix, captain-included rates, and pricing by region
- **Lead generation for marine businesses** — find active listings and owners in a target area

### FAQ

**Is this affiliated with Boatsetter or GetMyBoat?**
No. This is an independent, third-party actor that reads each platform's public search results — no account or login required.

**Why do some listings show a price range instead of a single number?**
`priceAmount` is the starting price shown by the platform; `priceMaxAmount` (when present) is the top of the range for that boat's rate variations.

**Why don't fishing, houseboat, or sailboat filters return as many results as other types?**
Boatsetter's own site doesn't expose a jet-ski, houseboat, or fishing category filter directly, so those are matched from listing titles/descriptions there. On GetMyBoat, the fishing/houseboat/sailboat categories are cross-checked against each listing's own title and description (their upstream category tagging for these three was found to include unrelated luxury-yacht listings) — this keeps results on-topic but means fewer matches than a raw category count, and houseboat listings in particular are genuinely scarce on both platforms outside a handful of lake destinations.

**Why is capacity/boat type sometimes missing for a Boatsetter listing but always present for GetMyBoat?**
Both platforms are queried for every record; if a specific listing's detail page doesn't publish a value for that field, it's simply left out rather than shown as empty.

**How current is the pricing?**
Pricing reflects each platform's live search results for the trip date you provide (or one week from today by default), including any date-specific discounts the owner has set.

**Can I search a destination outside the US?**
Yes — both platforms list boats worldwide. Use a city/region name, e.g. `"Sydney, Australia"` or `"Lake Como, Italy"`.

### Limitations

This actor covers destination search (with boat-type, capacity, price, and captain filters) on both platforms, which is how the vast majority of users browse Boatsetter and GetMyBoat. It does not offer a direct "fetch one listing by URL/ID" mode — Boatsetter's detail-page fetch is already used internally for enrichment but isn't exposed as a standalone input, and GetMyBoat has no public per-listing endpoint independent of a location search. If you need a specific known listing refreshed, re-run a destination search covering that listing's market; it will be included if still active.

# Actor input Schema

## `platform` (type: `string`):

Which site(s) to search. "Both" merges and de-duplicates results from Boatsetter and GetMyBoat.

## `location` (type: `string`):

City/region to search, e.g. "Miami, FL", "San Diego, CA", "Lake Tahoe", "Chicago, IL".

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

Filter by boat type. "Any" returns all types. Coverage of jet ski / houseboat is best-effort on Boatsetter (native on GetMyBoat).

## `tripDate` (type: `string`):

Trip date as YYYY-MM-DD. Leave blank to use a date one week from today (affects live pricing/availability shown by each platform).

## `minCapacity` (type: `integer`):

Only return boats that fit at least this many guests.

## `captainOption` (type: `string`):

Filter by whether a captain is included in the listed price.

## `priceMinPerHour` (type: `integer`):

Only return boats priced at or above this hourly rate (USD).

## `priceMaxPerHour` (type: `integer`):

Only return boats priced at or below this hourly rate (USD).

## `sortBy` (type: `string`):

Order of the returned listings.

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

Maximum number of boat listings to return (across selected platform(s)).

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

Optional. Both sites are publicly accessible without proxy; enable Apify Proxy (AUTO) only if you see repeated blocking.

## Actor input object example

```json
{
  "platform": "both",
  "location": "Miami, FL",
  "boatType": "any",
  "captainOption": "any",
  "sortBy": "relevance",
  "maxItems": 30,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `listings` (type: `string`):

Dataset containing all scraped boat charter/rental 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 = {
    "platform": "both",
    "location": "Miami, FL",
    "boatType": "any",
    "captainOption": "any",
    "sortBy": "relevance",
    "maxItems": 30
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/boat-charter-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 = {
    "platform": "both",
    "location": "Miami, FL",
    "boatType": "any",
    "captainOption": "any",
    "sortBy": "relevance",
    "maxItems": 30,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/boat-charter-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 '{
  "platform": "both",
  "location": "Miami, FL",
  "boatType": "any",
  "captainOption": "any",
  "sortBy": "relevance",
  "maxItems": 30
}' |
apify call crawlerbros/boat-charter-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Boat Charter Scraper - Boatsetter & GetMyBoat",
        "description": "Scrape boat rental and charter listings from Boatsetter and GetMyBoat - titles, boat type, capacity, hourly/daily price, captain availability, ratings, photos, and booking URLs for any destination worldwide.",
        "version": "1.0",
        "x-build-id": "xCpkZtW7RHkYgDfiZ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~boat-charter-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-boat-charter-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-charter-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-boat-charter-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-charter-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-boat-charter-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": [
                    "location"
                ],
                "properties": {
                    "platform": {
                        "title": "Platform",
                        "enum": [
                            "both",
                            "boatsetter",
                            "getmyboat"
                        ],
                        "type": "string",
                        "description": "Which site(s) to search. \"Both\" merges and de-duplicates results from Boatsetter and GetMyBoat.",
                        "default": "both"
                    },
                    "location": {
                        "title": "Destination",
                        "type": "string",
                        "description": "City/region to search, e.g. \"Miami, FL\", \"San Diego, CA\", \"Lake Tahoe\", \"Chicago, IL\".",
                        "default": "Miami, FL"
                    },
                    "boatType": {
                        "title": "Boat type",
                        "enum": [
                            "any",
                            "powerboat",
                            "yacht",
                            "sailboat",
                            "pontoon",
                            "fishing",
                            "houseboat",
                            "jetski"
                        ],
                        "type": "string",
                        "description": "Filter by boat type. \"Any\" returns all types. Coverage of jet ski / houseboat is best-effort on Boatsetter (native on GetMyBoat).",
                        "default": "any"
                    },
                    "tripDate": {
                        "title": "Trip date",
                        "type": "string",
                        "description": "Trip date as YYYY-MM-DD. Leave blank to use a date one week from today (affects live pricing/availability shown by each platform)."
                    },
                    "minCapacity": {
                        "title": "Minimum capacity (guests)",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Only return boats that fit at least this many guests."
                    },
                    "captainOption": {
                        "title": "Captain",
                        "enum": [
                            "any",
                            "captained",
                            "bareboat"
                        ],
                        "type": "string",
                        "description": "Filter by whether a captain is included in the listed price.",
                        "default": "any"
                    },
                    "priceMinPerHour": {
                        "title": "Minimum price (USD/hour)",
                        "minimum": 0,
                        "maximum": 50000,
                        "type": "integer",
                        "description": "Only return boats priced at or above this hourly rate (USD)."
                    },
                    "priceMaxPerHour": {
                        "title": "Maximum price (USD/hour)",
                        "minimum": 0,
                        "maximum": 50000,
                        "type": "integer",
                        "description": "Only return boats priced at or below this hourly rate (USD)."
                    },
                    "sortBy": {
                        "title": "Sort results by",
                        "enum": [
                            "relevance",
                            "priceAsc",
                            "priceDesc",
                            "ratingDesc"
                        ],
                        "type": "string",
                        "description": "Order of the returned listings.",
                        "default": "relevance"
                    },
                    "maxItems": {
                        "title": "Max results",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of boat listings to return (across selected platform(s)).",
                        "default": 30
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional. Both sites are publicly accessible without proxy; enable Apify Proxy (AUTO) only if you see repeated blocking.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
