# GetMyBoat Scraper (`parseforge/getmyboat-scraper`) Actor

Scrape boat rental and charter listings from GetMyBoat. Get prices, capacity, ratings, photos, owner info, and availability for 180,000+ boats. Filter by location, category, price range, and passenger capacity.

- **URL**: https://apify.com/parseforge/getmyboat-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Travel, E-commerce, Other
- **Stats:** 3 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 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/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

![ParseForge Banner](https://raw.githubusercontent.com/ParseForge/apify-assets/main/banner.jpg)

## 🚤 GetMyBoat Boat Rental Scraper

🚀 Collect structured boat rental and charter listings from GetMyBoat's marketplace of 180,000+ vessels. Get prices, capacity, ratings, photos, owner info, and availability for any location worldwide.

🕒 Last updated: 2026-04-23

GetMyBoat is the world's largest boat rental marketplace, connecting travelers with boat owners and charter operators. Manually browsing listings to compare prices, availability, and boat specs across locations is slow and impractical for serious market analysis.

The GetMyBoat Scraper automates this process, pulling structured listing data by location, boat category, price range, and capacity. Whether you are a marina analyzing rental prices, a travel company building comparison tools, or a researcher studying the charter market, this tool delivers clean data ready for analysis.

| | |
|---|---|
| **Target Audience** | Marina operators, travel companies, boat owners, market researchers |
| **Primary Use Cases** | Price benchmarking, competitive analysis, fleet planning, market research |

---

### 📋 What Does It Do

This tool collects boat rental listing data from GetMyBoat, returning structured records with pricing, specs, and owner details. It delivers:

- ⛵ **Listings** - headlines, prices, capacity, ratings, and instant book status
- 📍 **Location** - city, state, country, lat/lon, departure locations
- 👤 **Owner info** - name, super owner status, total bookings
- 🚤 **Boat details** - make, model, year, length, captain options
- 📸 **Photos** - multiple images with dimensions and descriptions
- 💰 **Pricing** - per-hour/day rates, minimums, captain costs, deposits

---

### 🎬 How to Use the GetMyBoat Scraper - Full Demo

🚧 Demo video coming soon. Follow the step-by-step instructions below to get started in under 2 minutes.

---

### ⚙️ Input

Configure your search with location, category, and pricing filters.

<table>
<thead>
<tr><th>Field</th><th>Type</th><th>Description</th></tr>
</thead>
<tbody>
<tr><td><b>Location</b></td><td>Select</td><td>Popular boating destination or "Custom" for a custom slug</td></tr>
<tr><td><b>Custom Location</b></td><td>String</td><td>Custom location slug (e.g. "Boston--MA--United-States")</td></tr>
<tr><td><b>Max Items</b></td><td>Integer</td><td>Free users: Limited to 10 items. Paid users: up to 1,000,000</td></tr>
<tr><td><b>Category</b></td><td>Select</td><td>Filter by boat type (Yacht, Sailboat, Pontoon, Fishing Charter, etc.)</td></tr>
<tr><td><b>Min Price</b></td><td>Integer</td><td>Minimum price filter</td></tr>
<tr><td><b>Max Price</b></td><td>Integer</td><td>Maximum price filter</td></tr>
<tr><td><b>Min Guest Capacity</b></td><td>Integer</td><td>Minimum number of guests the boat must accommodate</td></tr>
<tr><td><b>Include Full Details</b></td><td>Boolean</td><td>Fetch detail page for each listing (make, model, year, features)</td></tr>
</tbody>
</table>

**Example 1 - Miami pontoon boats:**
```json
{
    "location": "Miami--FL--United-States",
    "maxItems": 100,
    "categorySlug": "pontoon-boat-rentals",
    "includeDetails": true
}
````

**Example 2 - Budget-friendly Key West boats:**

```json
{
    "location": "Key-West--FL--United-States",
    "maxItems": 50,
    "maxPrice": 200,
    "capacity": 6
}
```

> ⚠️ Free users are limited to 10 items per run. [Sign up for a paid plan](https://console.apify.com/sign-up?fpr=vmoqkp) to unlock up to 1,000,000 records.

***

### 📊 Output

#### 🧾 Output Schema

| Field | Type | Description |
|-------|------|-------------|
| photoUrl | string | Primary listing photo URL |
| headline | string | Listing title |
| url | string | Listing page URL |
| capacity | integer | Maximum guest capacity |
| reviewAverage | number | Average review rating |
| price | number | Listing price |
| priceUnit | string | Price unit (hour, day) |
| currency | string | Currency code |
| instabookEnabled | boolean | Instant booking available |
| captainOption | string | Captain included/optional/none |
| make | string | Boat manufacturer |
| model | string | Boat model |
| year | integer | Boat year |
| city | string | City |
| state | string | State |
| ownerIsSuperOwner | boolean | Super owner badge |
| totalBookings | integer | Owner's total bookings |
| scrapedAt | string | Timestamp of data collection |

#### 📦 Sample Output

**Sample 1 - Yacht rental:**

```json
{
    "photoUrl": "https://images.getmyboat.com/yacht-photo.jpg",
    "headline": "40ft Sea Ray Sundancer - Perfect for Bay Cruising",
    "url": "https://www.getmyboat.com/boats/40ft-sea-ray",
    "capacity": 12,
    "reviewAverage": 4.9,
    "price": 250,
    "priceUnit": "hour",
    "currency": "USD",
    "instabookEnabled": true,
    "captainOption": "included",
    "make": "Sea Ray",
    "model": "Sundancer",
    "year": 2020,
    "city": "Miami",
    "state": "FL",
    "ownerIsSuperOwner": true,
    "totalBookings": 156,
    "scrapedAt": "2026-04-08T12:00:00.000Z"
}
```

**Sample 2 - Pontoon boat:**

```json
{
    "photoUrl": "https://images.getmyboat.com/pontoon-photo.jpg",
    "headline": "24ft Pontoon Party Boat with Bluetooth Speakers",
    "url": "https://www.getmyboat.com/boats/24ft-pontoon",
    "capacity": 10,
    "reviewAverage": 4.7,
    "price": 125,
    "priceUnit": "hour",
    "currency": "USD",
    "instabookEnabled": true,
    "captainOption": "none",
    "make": "Bennington",
    "model": "SX",
    "year": 2022,
    "city": "Key West",
    "state": "FL",
    "ownerIsSuperOwner": false,
    "totalBookings": 42,
    "scrapedAt": "2026-04-08T12:00:00.000Z"
}
```

**Sample 3 - Fishing charter:**

```json
{
    "photoUrl": "https://images.getmyboat.com/fishing-photo.jpg",
    "headline": "32ft Deep Sea Fishing Charter - All Gear Included",
    "url": "https://www.getmyboat.com/boats/32ft-fishing",
    "capacity": 6,
    "reviewAverage": 5.0,
    "price": 400,
    "priceUnit": "half-day",
    "currency": "USD",
    "instabookEnabled": false,
    "captainOption": "included",
    "make": "Grady-White",
    "model": "Canyon",
    "year": 2019,
    "city": "Fort Lauderdale",
    "state": "FL",
    "ownerIsSuperOwner": true,
    "totalBookings": 230,
    "scrapedAt": "2026-04-08T12:00:00.000Z"
}
```

***

### ✨ Why Choose the GetMyBoat Scraper?

| Advantage | Details |
|-----------|---------|
| 🚤 **180,000+ boats** | Access the world's largest boat rental marketplace |
| 📍 **Location filtering** | Search 20+ popular destinations or any custom location |
| 🏷️ **Category filters** | Yachts, sailboats, pontoons, fishing charters, jet skis, and more |
| 💰 **Price range filtering** | Set min/max price to find boats in your budget |
| 📊 **Detail enrichment** | Get make, model, year, and features with one toggle |
| ⏰ **Scheduled monitoring** | Track pricing changes over time with automated runs |
| 🚀 **No coding required** | Point-and-click interface for anyone |

***

### 📈 How Does It Compare?

| Feature | Our Tool | Manual Browsing |
|---------|----------|-----------------|
| Bulk listing collection | Up to 1M listings | Page-by-page |
| Location + category filters | Combined | Limited UI |
| Structured pricing data | JSON/CSV/Excel | Visual only |
| Owner and booking info | Included | Click each listing |
| Automated scheduling | Daily/weekly | Not possible |
| Export formats | JSON, CSV, Excel | Not supported |

***

### 🚀 How to Use

1. **Sign Up** - [Create a free account w/ $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp) (takes 2 minutes)
2. **Find the Tool** - Search for "GetMyBoat Scraper" in the Apify Store
3. **Set Input** - Choose your location, category, and price filters
4. **Run It** - Click "Start" and get structured boat data in seconds
5. **Download Data** - Export results as CSV, Excel, or JSON from the Dataset tab

***

### 💼 Business Use Cases

**Marina and Charter Operators:**

- Analyze rental prices and competition in your area
- Benchmark your pricing against similar listings

**Travel Companies:**

- Build boat booking comparison tools with real pricing data
- Monitor availability and seasonal pricing trends

**Boat Owners:**

- Research competitive pricing before listing your vessel
- Track similar listings in your region

**Market Researchers:**

- Study charter market trends by location, category, and price
- Analyze super owner performance and booking patterns

***

### 🌟 Beyond business use cases

Data like this powers more than commercial workflows. The same structured records support research, education, civic projects, and personal initiatives.

<table>
<tr>
<td width="50%">

#### 🎓 Research and academia

- Empirical datasets for papers, thesis work, and coursework
- Longitudinal studies tracking changes across snapshots
- Reproducible research with cited, versioned data pulls
- Classroom exercises on data analysis and ethical scraping

</td>
<td width="50%">

#### 🎨 Personal and creative

- Side projects, portfolio demos, and indie app launches
- Data visualizations, dashboards, and infographics
- Content research for bloggers, YouTubers, and podcasters
- Hobbyist collections and personal trackers

</td>
</tr>
<tr>
<td width="50%">

#### 🤝 Non-profit and civic

- Transparency reporting and accountability projects
- Advocacy campaigns backed by public-interest data
- Community-run databases for local issues
- Investigative journalism on public records

</td>
<td width="50%">

#### 🧪 Experimentation

- Prototype AI and machine-learning pipelines with real data
- Validate product-market hypotheses before engineering spend
- Train small domain-specific models on niche corpora
- Test dashboard concepts with live input

</td>
</tr>
</table>

### 🔌 Automating Your Boat Data Collection

Schedule runs to monitor pricing changes and new listings automatically. Use the Apify scheduler for daily, weekly, or monthly data collection and push results to your tools via integrations.

***

### ❓ FAQ

**🚤 What is GetMyBoat?**
GetMyBoat is the world's largest boat rental and water experience marketplace, with over 180,000 boats available in 184 countries.

**📍 What locations are supported?**
You can search 20 popular destinations from the dropdown or enter any custom location slug in the City--State--Country format.

**🏷️ What boat categories can I filter by?**
Yachts, sailboats, pontoons, fishing charters, jet skis, houseboats, catamarans, speedboats, kayaks, and party boats.

**📊 What does "Include Full Details" do?**
It fetches each listing's detail page to get additional fields like make, model, year, description, features, and AI summary. This is slower but more complete.

**⚡ How long does a run take?**
Basic mode: about 1-2 seconds per 100 listings. With details enabled, each listing takes an additional 0.5-1 second.

**💰 Is there a free trial?**
Yes. Free users can collect up to 10 listings per run.

**📅 Can I schedule regular runs?**
Yes. Use the Apify scheduler for daily, weekly, or monthly price monitoring.

**🌍 Does it work internationally?**
Yes. GetMyBoat has listings in 184 countries. Use the custom location option for international searches.

**📊 What format can I download?**
JSON, CSV, or Excel directly from the Apify platform.

**👤 Does it include owner information?**
Yes. Each listing includes owner name, super owner status, and total booking count.

**💲 Is pricing data included?**
Yes. You get per-hour/day rates, captain costs, and booking details.

**🔌 Can I connect it to my tools?**
Yes. Use integrations with Make, Zapier, Google Sheets, Slack, and more.

***

### 🔌 Integrate GetMyBoat Scraper with Any App

Connect your boat data to thousands of apps using these integrations:

- [Make](https://docs.apify.com/platform/integrations/make) - Automate boat data workflows
- [Zapier](https://docs.apify.com/platform/integrations/zapier) - Sync listing data to your tools
- [Slack](https://docs.apify.com/platform/integrations/slack) - Get notified about pricing changes
- [Google Drive](https://docs.apify.com/platform/integrations/drive) - Export to spreadsheets
- [Airbyte](https://docs.apify.com/platform/integrations/airbyte) - Sync to your data warehouse
- [Webhooks](https://docs.apify.com/platform/integrations/webhooks) - Trigger actions when runs complete

***

### 🔗 Recommended Actors

Looking for more data collection tools? Check out these related actors:

| Actor | Description | Link |
|-------|-------------|------|
| YATCO Yacht Listing Scraper | Yacht listings for sale | [Link](https://apify.com/parseforge/yatco-scraper) |
| Fraser Yachts Scraper | Luxury yacht listings | [Link](https://apify.com/parseforge/fraseryachts-scraper) |
| Click\&Boat Scraper | Boat rental marketplace | [Link](https://apify.com/parseforge/click-boat-scraper) |
| Bring A Trailer Auctions Scraper | Vehicle auction listings | [Link](https://apify.com/parseforge/bringatrailer-auctions-scraper) |
| Flippa Scraper | Online business for sale listings | [Link](https://apify.com/parseforge/flippa-scraper) |

**Pro Tip:** 💡 Browse the full [ParseForge catalog](https://apify.com/parseforge) to find more data tools.

***

### 🆘 Need Help?

- Check the FAQ section above for common questions
- Visit the [Apify documentation](https://docs.apify.com) for platform guides
- Contact us at [Tally contact form](https://tally.so/r/BzdKgA)

***

> **⚠️ Disclaimer:** This Actor is an independent tool and is not affiliated with, endorsed by, or connected to GetMyBoat. It accesses only publicly available data.

# Actor input Schema

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

Select a popular boating destination or enter a custom location slug.

## `customLocation` (type: `string`):

Enter a custom location slug (only used when Location is set to Custom). Format: City--State--Country (e.g. Boston--MA--United-States).

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

## `categorySlug` (type: `string`):

Filter by boat type.

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

Minimum price filter.

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

Maximum price filter.

## `capacity` (type: `integer`):

Minimum number of guests the boat must accommodate.

## `includeDetails` (type: `boolean`):

Fetch the detail page for each listing to get extra fields: make, model, year, description, features, prices, AI summary, etc. Slower but more complete.

## Actor input object example

```json
{
  "location": "Miami--FL--United-States",
  "maxItems": 10,
  "includeDetails": false
}
```

# Actor output Schema

## `results` (type: `string`):

Dataset with all scraped boat 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 = {
    "location": "Miami--FL--United-States",
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/getmyboat-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 = {
    "location": "Miami--FL--United-States",
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/getmyboat-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 '{
  "location": "Miami--FL--United-States",
  "maxItems": 10
}' |
apify call parseforge/getmyboat-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "GetMyBoat Scraper",
        "description": "Scrape boat rental and charter listings from GetMyBoat. Get prices, capacity, ratings, photos, owner info, and availability for 180,000+ boats. Filter by location, category, price range, and passenger capacity.",
        "version": "0.0",
        "x-build-id": "SvjY5Bum8DaIVZqnP"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~getmyboat-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-getmyboat-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/parseforge~getmyboat-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-getmyboat-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/parseforge~getmyboat-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-getmyboat-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",
                "properties": {
                    "location": {
                        "title": "Location",
                        "enum": [
                            "Miami--FL--United-States",
                            "San-Diego--CA--United-States",
                            "Fort-Lauderdale--FL--United-States",
                            "Key-West--FL--United-States",
                            "Tampa--FL--United-States",
                            "Naples--FL--United-States",
                            "Chicago--IL--United-States",
                            "New-York--NY--United-States",
                            "Los-Angeles--CA--United-States",
                            "Seattle--WA--United-States",
                            "Honolulu--HI--United-States",
                            "Lake-Tahoe--CA--United-States",
                            "Austin--TX--United-States",
                            "Charleston--SC--United-States",
                            "Destin--FL--United-States",
                            "Newport-Beach--CA--United-States",
                            "Cancun--Quintana-Roo--Mexico",
                            "Barcelona--Catalonia--Spain",
                            "Dubrovnik--Dubrovnik-Neretva--Croatia",
                            "Athens--Attica--Greece",
                            "custom"
                        ],
                        "type": "string",
                        "description": "Select a popular boating destination or enter a custom location slug."
                    },
                    "customLocation": {
                        "title": "Custom Location",
                        "type": "string",
                        "description": "Enter a custom location slug (only used when Location is set to Custom). Format: City--State--Country (e.g. Boston--MA--United-States)."
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    },
                    "categorySlug": {
                        "title": "Category",
                        "enum": [
                            "",
                            "yacht-rentals",
                            "sailboat-rentals",
                            "pontoon-boat-rentals",
                            "fishing-charters",
                            "jet-ski-rentals",
                            "houseboat-rentals",
                            "catamaran-rentals",
                            "speedboat-rentals",
                            "kayak-rentals",
                            "party-boat-rentals"
                        ],
                        "type": "string",
                        "description": "Filter by boat type."
                    },
                    "minPrice": {
                        "title": "Min Price",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum price filter."
                    },
                    "maxPrice": {
                        "title": "Max Price",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum price filter."
                    },
                    "capacity": {
                        "title": "Min Guest Capacity",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Minimum number of guests the boat must accommodate."
                    },
                    "includeDetails": {
                        "title": "Include Full Details",
                        "type": "boolean",
                        "description": "Fetch the detail page for each listing to get extra fields: make, model, year, description, features, prices, AI summary, etc. Slower but more complete.",
                        "default": 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
