# Yatco Yacht Scraper (`solidcode/yatco-yacht-scraper`) Actor

\[💰 $3.0 / 1K] Extract yacht listings from YATCO — for-sale vessels with full specs, builder, year, length, price, location, broker name, and gallery images. Filter by type, length, price, year, builder, and country.

- **URL**: https://apify.com/solidcode/yatco-yacht-scraper.md
- **Developed by:** [SolidCode](https://apify.com/solidcode) (community)
- **Categories:** Other, Real estate, Travel
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.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.

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

## YATCO Yachts Scraper — Yacht Listings, Specs, Brokers, Prices

Extract every yacht for sale on YATCO with full specs, prices, locations, builders, brokers, and gallery images. Built for yacht brokers, marine intelligence teams, market analysts, and lead-gen pros who need clean, structured listing data — not screenshots.

### Why This Scraper?

- **Full YATCO For-Sale catalog** — 6,000+ yacht listings searchable by builder, type, length, price, year, condition, and country.
- **Rich per-yacht detail** — Builder, model, year, length, beam, cabins, hull material, USD price, native-currency price, full specification sheet, broker name, brokerage, location, primary image, and the complete gallery.
- **Smart URL paste** — Drop any YATCO search-results URL straight in (`/yachts-for-sale/type-motor/brand-sunseeker/`, `/condition-new/`, `/length-80-150/`, `/country-united-states/`). The actor reads the filters out of the path and applies your structured filters on top.
- **Free-text searches** — "Sunseeker", "Azimut 80", "Lagoon catamaran" — anything you would type into the YATCO search bar.
- **Price normalization to USD** — Listings priced in EUR, GBP, or AED are normalized to USD so you can sort and compare instantly. Native amount and currency are preserved in `priceRaw`.
- **Pay only for results** — No compute charges. You pay a flat rate per row returned. See Pricing below.
- **Designed for downstream tooling** — Clean tabular output works out of the box with Google Sheets, Zapier, Make, n8n, or your own database via the Apify API.

### Use Cases

**Market Research & Pricing Intelligence**
- Track average asking prices by builder, length class, or country.
- Spot inventory gluts in segments where supply is climbing faster than demand.
- Benchmark a new build against comparable used hulls in the same length and year band.

**Brokerage Intelligence & Competitor Monitoring**
- Monitor which brokerages are listing the most yachts — and where.
- Track which builders are dominating central agency listings vs co-brokered.
- Get notified when a competitor brokerage adds a high-value central listing.

**Lead Generation**
- Build broker contact lists segmented by region and yacht type.
- Pull every Sunseeker, Princess, Ferretti, or Azimut listing into your CRM weekly.
- Identify brokerages with thin inventory in growth markets.

**Inventory & Listing Sync**
- Keep your own listing site or marine marketplace in sync with YATCO daily.
- Power a buyer-alert email from a fresh dataset of new arrivals matching saved criteria.
- Feed product feeds for partner sites and yacht aggregator services.

**Investor Due Diligence**
- Quantify total addressable inventory in a target country or yacht class.
- Snapshot the global mega-yacht and superyacht market for fund or M&A research.
- Validate broker-supplied market sizing claims against live listings.

### Getting Started

#### All yachts for sale (defaults)

The simplest possible run. Returns up to 1,000 listings with full detail enrichment.

```json
{
    "maxResults": 50
}
````

#### Sunseeker motor yachts in the United States

Combine a builder, a yacht type, a length range, and a country filter.

```json
{
    "yachtTypes": ["motor"],
    "builders": ["Sunseeker"],
    "country": "us",
    "lengthMinFt": 60,
    "lengthMaxFt": 150,
    "maxResults": 200
}
```

#### Free-text searches

Same syntax you would type into YATCO's search bar.

```json
{
    "searchQueries": ["Azimut 80", "Lagoon catamaran", "Princess Y85"],
    "yearMin": 2018,
    "maxResults": 150
}
```

#### Paste a YATCO URL directly

The actor reads the filters out of the URL path. Layer extra structured filters on top.

```json
{
    "searchUrls": [
        "https://www.yatco.com/yachts-for-sale/type-motor/brand-sunseeker/",
        "https://www.yatco.com/yachts-for-sale/condition-new/length-80-150/"
    ],
    "maxResults": 300
}
```

#### Fast & cheap mode (search-card data only)

Skip the per-yacht detail page fetch. About 5-10x faster and cheaper for large pulls.

```json
{
    "yachtTypes": ["mega-yacht"],
    "includeDetails": false,
    "maxResults": 1000
}
```

### Input Reference

#### What to scrape

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `searchUrls` | string\[] | `[]` | Paste one or more YATCO URLs directly. Accepts search-result pages such as `https://www.yatco.com/yachts-for-sale/type-motor/`. The URL's path filters (type, brand, condition, length, country) are detected and applied; the structured filters below are then layered on top as additional constraints. |
| `searchQueries` | string\[] | `[]` | Free-text searches such as "Sunseeker", "Azimut 80", or "Lagoon catamaran". Each query runs independently and respects the filters below. |
| `yachtCategory` | string | `"sale"` | Which YATCO catalog to search. Options: **For Sale**, **For Charter (not supported in v1)**, **New Build (not supported in v1)**. Only For Sale is supported in v1 — charter and new-build will fall through to the For-Sale catalog with a warning. Ignored for YATCO URLs (the URL already specifies the catalog). |

#### Filters

All filters are optional — leave blank for no filter. These apply to Search Queries only; YATCO URLs use whatever filters are already in the URL.

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `yachtTypes` | string\[] | `[]` | Only include yachts of these types. Options: **Motor Yacht**, **Sailing Yacht**, **Catamaran**, **Sport Fisherman**, **Mega Yacht / Superyacht**, **Expedition / Explorer**, **Center Console**. Leave empty for all types. |
| `condition` | string | `"any"` | Filter by new vs used vessels. Options: **Any condition**, **New only**, **Used only**. |
| `lengthMinFt` | integer | | Only include yachts at or above this length in feet. Leave empty for no minimum. |
| `lengthMaxFt` | integer | | Only include yachts at or below this length in feet. Leave empty for no maximum. |
| `priceMinUsd` | integer | | Only include listings at or above this price (USD). Leave empty for no minimum. |
| `priceMaxUsd` | integer | | Only include listings at or below this price (USD). Leave empty for no maximum. |
| `yearMin` | integer | | Earliest build year. Leave empty for no minimum. |
| `yearMax` | integer | | Latest build year. Leave empty for no maximum. |
| `builders` | string\[] | `[]` | Only include yachts from these builders (e.g. "Sunseeker", "Azimut", "Ferretti"). Leave empty for all builders. |
| `country` | string | | Filter listings to a specific country. Options: **United States**, **Canada**, **Mexico**, **United Kingdom**, **France**, **Italy**, **Spain**, **Greece**, **Turkey**, **Germany**, **Netherlands**, **Portugal**, **Croatia**, **Malta**, **United Arab Emirates**, **Australia**, **New Zealand**, **Thailand**, **Singapore**, **Japan**, **Brazil**, **Monaco**, **The Bahamas**, **China**, **Cyprus**, **Montenegro**, **Taiwan**, **Saint Martin**, **Panama**, **Antigua And Barbuda**. For any other country, paste a YATCO URL with `/country-<slug>/`. Leave empty for worldwide results. |

#### Output

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `includeDetails` | boolean | `true` | When enabled, the actor visits each yacht's detail page for the full marketing description and the complete gallery of large images. Adds about 1–2 seconds per yacht. Disable for faster, cheaper runs that return only the search-card data. |
| `maxResults` | integer | `1000` | Per-run hard cap on rows across all queries and URLs combined. Default 1000 — set to 0 for no cap (be careful: the full YATCO catalog is 6000+ listings). The actor stops requesting new pages once this number is reached but keeps the full final page even if it slightly overshoots. |

### Output

Each row is one yacht listing.

```json
{
    "recordType": "yacht_listing",
    "id": "1234567",
    "name": "Serenity",
    "url": "https://www.yatco.com/yacht/120-sunseeker-motor-yacht-2021-1234567/",
    "category": "sale",
    "vesselType": "Motor Yacht",
    "builder": "Sunseeker",
    "model": "120 Yacht",
    "yearBuilt": 2021,
    "condition": "used",
    "lengthFt": 120.0,
    "lengthM": 36.58,
    "beamFt": 25.5,
    "cabins": 5,
    "hullMaterial": "Fiberglass",
    "priceUsd": 12500000,
    "priceRaw": { "amount": 11500000, "currency": "EUR" },
    "priceText": "€11,500,000",
    "locationCity": "Fort Lauderdale",
    "locationRegion": "Florida",
    "locationCountry": "United States",
    "image": "https://cloud.yatco.com/ForSale/Vessel/Photo/1234567/medium_1.webp",
    "images": [
        "https://cloud.yatco.com/ForSale/Vessel/Photo/1234567/large_1.webp",
        "https://cloud.yatco.com/ForSale/Vessel/Photo/1234567/large_2.webp"
    ],
    "description": "Stunning tri-deck Sunseeker 120 in turn-key condition...",
    "specs": {
        "engineCount": 2,
        "engineMake": "MTU",
        "engineModel": "16V 2000 M96L",
        "engineFuelType": "Diesel",
        "fuelCapacityGallons": 4500,
        "waterCapacityGallons": 800,
        "grossTonnage": 220,
        "draftMaxFeet": 7.2,
        "beamMeters": 7.77,
        "heads": 6,
        "sleeps": 12,
        "subCategory": "Tri Deck",
        "mainCategory": "Motor Yacht",
        "vesselTypeText": "Motor",
        "refitYear": 2023,
        "daysOnMarket": 142
    },
    "brokerName": "Jane Doe",
    "brokerage": "Acme Yacht Sales",
    "scrapedAt": "2026-04-25T14:32:00+00:00",
    "sourceInput": "https://www.yatco.com/yachts-for-sale/type-motor/brand-sunseeker/"
}
```

#### All Available Fields

| Field | Type | Description |
|-------|------|-------------|
| `recordType` | string | Discriminator — always `"yacht_listing"` for this actor. |
| `id` | string | YATCO vessel ID (stable identifier). |
| `name` | string | Yacht name. |
| `url` | string | Canonical YATCO detail-page URL. |
| `category` | string | Listing category — currently always `"sale"`. |
| `vesselType` | string | Best yacht-type label (e.g. "Motor Yacht", "Sailing Yacht", "Catamaran"). |
| `builder` | string | Builder / manufacturer name (title-cased, e.g. "Sunseeker"). |
| `model` | string | Model name (e.g. "120 Yacht"). |
| `yearBuilt` | number | Build year. |
| `condition` | string | `"new"` or `"used"`. |
| `lengthFt` | number | Length overall in feet. |
| `lengthM` | number | Length overall in meters. |
| `beamFt` | number | Beam in feet. |
| `cabins` | number | Number of staterooms. |
| `hullMaterial` | string | Hull material (e.g. "Fiberglass", "Aluminum", "Steel"). |
| `priceUsd` | number | Asking price normalized to USD. May be empty for "Price on Request" listings. |
| `priceRaw` | object | Native-currency price as `{ amount, currency }` when the listing is priced in a non-USD currency. |
| `priceText` | string | Display-formatted price as it appears on YATCO (e.g. "€11,500,000", "Price on Request"). |
| `locationCity` | string | City. |
| `locationRegion` | string | State / region / province. |
| `locationCountry` | string | Country. |
| `image` | string | Primary photo URL. |
| `images` | string\[] | Full gallery — large image URLs. Populated when `includeDetails=true`. |
| `description` | string | Full marketing description from the yacht's detail page. Populated when `includeDetails=true`. |
| `specs` | object | Specification sheet — engine count/make/model/fuel type, fuel and water capacity (gallons), gross tonnage, draft (ft and m), beam (m), heads, sleeps, sub-category, main category, refit year, days on market. |
| `brokerName` | string | Listing broker's display name. |
| `brokerage` | string | Listing brokerage / company name. |
| `scrapedAt` | string | UTC ISO-8601 timestamp when this row was collected. |
| `sourceInput` | string | The query, URL, or filter set that produced this row — useful when running multiple jobs in one run. |

### Tips for Best Results

- **Disable `includeDetails` for speed and cost.** With detail enrichment on, the actor visits one detail page per yacht — about 1–2 seconds each. For a 1,000-yacht pull that adds ~15–30 minutes of runtime, and the per-row compute cost is roughly 6× the search-only path. If you only need search-card data (builder, model, year, length, USD price, location, broker name, primary image), set `includeDetails: false`.
- **A small share of yachts are delisted.** YATCO occasionally keeps a sold or removed yacht in its search index after the detail page has been taken down. Those rows still ship the search-card fields but `description` and `images` will be empty. The end-of-run log line tells you exactly how many.
- **Combine a URL paste with structured filters** — paste a YATCO URL for the broad scope (e.g. `/yachts-for-sale/type-motor/`), then use `lengthMinFt` / `priceMaxUsd` / `country` to narrow further.
- **Use builder names, not slugs.** "Sunseeker", "Azimut", "Ocean Alexander" all work. Capitalization is normalized for you.
- **Start small.** Run with `maxResults: 50` first to confirm your filter combo returns what you expect. Then raise the cap.
- **Scheduled runs work great** — run weekly or daily on the Apify console to maintain a fresh inventory dataset. Pair with a webhook to trigger downstream automation.

### Good to Know

- **Detail enrichment is slower.** With `includeDetails: true` (default) the actor performs roughly one extra request per yacht to fetch the long-form description and the full image gallery. Disable it for fast bulk pulls of search-card data.
- **Some yachts may be delisted.** A small fraction of listings in YATCO's search index point to detail pages that have been removed. For those rows the core fields (builder, model, year, length, price, location, broker name, primary image) are still emitted, but `description` and `images` will be empty.
- **Prices are normalized to USD** when YATCO publishes a USD price. For listings priced in EUR, GBP, AED, or other native currencies, the `priceUsd` field carries YATCO's USD conversion, and `priceRaw` plus `priceText` preserve the original amount and display string.
- **v1 supports yachts For Sale only.** Charter and new-build catalog options are accepted in the input but currently fall through to the For-Sale catalog with a warning. Charter and new-build coverage is on the roadmap.
- **URL paste accepts canonical YATCO filter URLs** — `/yachts-for-sale/type-motor/`, `/condition-new/`, `/brand-azimut/`, `/length-60-100/`, `/country-united-states/`, and any combination of those path segments.

### Pricing

**$3 per 1,000 results.** No compute charges — you only pay per result returned.

| Results | Cost |
|---------|------|
| 100 | $0.30 |
| 1,000 | $3.00 |
| 10,000 | $30.00 |

Pricing is locked to the pay-per-result model — runtime, proxy traffic, and storage are included.

### Integrations

Export results in JSON, CSV, Excel, or XML. Connect to your stack via:

- **Apify API** — Full programmatic access to runs and datasets.
- **Webhooks** — Get notified the moment a run finishes.
- **Google Sheets** — Direct spreadsheet export, ideal for ad-hoc analysis.
- **Zapier** / **Make** / **n8n** — Pipe results into 1,000+ apps and your own workflow automations.

### Legal & Ethical Use

This actor is intended for legitimate market research, brokerage intelligence, lead generation, and inventory analysis. You are responsible for complying with applicable laws, the target site's terms of service, and personal-data regulations in your jurisdiction. Do not use the extracted data for spam, harassment, fraud, or any unlawful purpose. Broker contact details should only be used in compliance with anti-spam and data-protection rules that apply to you.

# Actor input Schema

## `searchUrls` (type: `array`):

Paste one or more YATCO URLs directly. Accepts search-result pages such as https://www.yatco.com/yachts-for-sale/type-motor/. The URL's path filters (type, brand, condition, length, country) are detected and applied; the structured filters below are then layered on top as additional constraints.

## `searchQueries` (type: `array`):

Free-text searches such as "Sunseeker", "Azimut 80", or "Lagoon catamaran". Each query runs independently and respects the filters below.

## `yachtCategory` (type: `string`):

Which YATCO catalog to search. Only "For Sale" is supported in v1 — "For Charter" and "New Build" will fall through to the For-Sale catalog with a warning. (Charter and new-build coverage is on the roadmap.) Ignored for YATCO URLs (the URL already specifies the catalog).

## `yachtTypes` (type: `array`):

Only include yachts of these types. Leave empty for all types.

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

Filter by new vs used vessels.

## `lengthMinFt` (type: `integer`):

Only include yachts at or above this length. Leave empty for no minimum.

## `lengthMaxFt` (type: `integer`):

Only include yachts at or below this length. Leave empty for no maximum.

## `priceMinUsd` (type: `integer`):

Only include listings at or above this price (USD). Leave empty for no minimum.

## `priceMaxUsd` (type: `integer`):

Only include listings at or below this price (USD). Leave empty for no maximum.

## `yearMin` (type: `integer`):

Earliest build year. Leave empty for no minimum.

## `yearMax` (type: `integer`):

Latest build year. Leave empty for no maximum.

## `builders` (type: `array`):

Only include yachts from these builders (e.g. "Sunseeker", "Azimut", "Ferretti"). Leave empty for all builders.

## `country` (type: `string`):

Filter listings to a specific country. Leave empty for worldwide results. Covers the 30 most-common YATCO listing countries — for any other country, paste a YATCO URL with `/country-<slug>/` instead.

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

When enabled, the actor visits each yacht's detail page for the full marketing description and the complete gallery of large images. Adds about 1–2 seconds per yacht. Disable for faster, cheaper runs that return only the search-card data.

## `maxResults` (type: `integer`):

Per-run hard cap on rows across all queries and URLs combined. Default 1000 — set to 0 for no cap (be careful: the full YATCO catalog is 6000+ listings). The actor stops requesting new pages once this number is reached but keeps the full final page even if it slightly overshoots.

## Actor input object example

```json
{
  "searchUrls": [],
  "searchQueries": [],
  "yachtCategory": "sale",
  "yachtTypes": [],
  "condition": "any",
  "builders": [],
  "includeDetails": true,
  "maxResults": 100
}
```

# Actor output Schema

## `overview` (type: `string`):

Table of yachts with the most useful fields at a glance.

## `details` (type: `string`):

Full per-yacht detail rows including description, all gallery images, full spec sheet, and broker name.

# 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 = {
    "searchUrls": [],
    "searchQueries": [],
    "yachtCategory": "sale",
    "yachtTypes": [],
    "condition": "any",
    "builders": [],
    "includeDetails": true,
    "maxResults": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/yatco-yacht-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 = {
    "searchUrls": [],
    "searchQueries": [],
    "yachtCategory": "sale",
    "yachtTypes": [],
    "condition": "any",
    "builders": [],
    "includeDetails": True,
    "maxResults": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/yatco-yacht-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 '{
  "searchUrls": [],
  "searchQueries": [],
  "yachtCategory": "sale",
  "yachtTypes": [],
  "condition": "any",
  "builders": [],
  "includeDetails": true,
  "maxResults": 100
}' |
apify call solidcode/yatco-yacht-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Yatco Yacht Scraper",
        "description": "[💰 $3.0 / 1K] Extract yacht listings from YATCO — for-sale vessels with full specs, builder, year, length, price, location, broker name, and gallery images. Filter by type, length, price, year, builder, and country.",
        "version": "1.0",
        "x-build-id": "mfqri8xnOyrDLp42l"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~yatco-yacht-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-yatco-yacht-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/solidcode~yatco-yacht-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-yatco-yacht-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/solidcode~yatco-yacht-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-yatco-yacht-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": {
                    "searchUrls": {
                        "title": "YATCO URLs",
                        "type": "array",
                        "description": "Paste one or more YATCO URLs directly. Accepts search-result pages such as https://www.yatco.com/yachts-for-sale/type-motor/. The URL's path filters (type, brand, condition, length, country) are detected and applied; the structured filters below are then layered on top as additional constraints.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchQueries": {
                        "title": "Search Queries",
                        "type": "array",
                        "description": "Free-text searches such as \"Sunseeker\", \"Azimut 80\", or \"Lagoon catamaran\". Each query runs independently and respects the filters below.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "yachtCategory": {
                        "title": "Yacht Category",
                        "enum": [
                            "sale",
                            "charter",
                            "new-build"
                        ],
                        "type": "string",
                        "description": "Which YATCO catalog to search. Only \"For Sale\" is supported in v1 — \"For Charter\" and \"New Build\" will fall through to the For-Sale catalog with a warning. (Charter and new-build coverage is on the roadmap.) Ignored for YATCO URLs (the URL already specifies the catalog).",
                        "default": "sale"
                    },
                    "yachtTypes": {
                        "title": "Yacht Types",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Only include yachts of these types. Leave empty for all types.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "motor",
                                "sailing",
                                "catamaran",
                                "sport-fisherman",
                                "mega-yacht",
                                "expedition",
                                "center-console"
                            ],
                            "enumTitles": [
                                "Motor Yacht",
                                "Sailing Yacht",
                                "Catamaran",
                                "Sport Fisherman",
                                "Mega Yacht / Superyacht",
                                "Expedition / Explorer",
                                "Center Console"
                            ]
                        },
                        "default": []
                    },
                    "condition": {
                        "title": "Condition",
                        "enum": [
                            "any",
                            "new",
                            "used"
                        ],
                        "type": "string",
                        "description": "Filter by new vs used vessels.",
                        "default": "any"
                    },
                    "lengthMinFt": {
                        "title": "Minimum Length (feet)",
                        "minimum": 0,
                        "maximum": 800,
                        "type": "integer",
                        "description": "Only include yachts at or above this length. Leave empty for no minimum."
                    },
                    "lengthMaxFt": {
                        "title": "Maximum Length (feet)",
                        "minimum": 0,
                        "maximum": 800,
                        "type": "integer",
                        "description": "Only include yachts at or below this length. Leave empty for no maximum."
                    },
                    "priceMinUsd": {
                        "title": "Minimum Price (USD)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include listings at or above this price (USD). Leave empty for no minimum."
                    },
                    "priceMaxUsd": {
                        "title": "Maximum Price (USD)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include listings at or below this price (USD). Leave empty for no maximum."
                    },
                    "yearMin": {
                        "title": "Minimum Year",
                        "minimum": 1900,
                        "maximum": 2035,
                        "type": "integer",
                        "description": "Earliest build year. Leave empty for no minimum."
                    },
                    "yearMax": {
                        "title": "Maximum Year",
                        "minimum": 1900,
                        "maximum": 2035,
                        "type": "integer",
                        "description": "Latest build year. Leave empty for no maximum."
                    },
                    "builders": {
                        "title": "Builders",
                        "type": "array",
                        "description": "Only include yachts from these builders (e.g. \"Sunseeker\", \"Azimut\", \"Ferretti\"). Leave empty for all builders.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "country": {
                        "title": "Country",
                        "enum": [
                            "us",
                            "ca",
                            "mx",
                            "gb",
                            "fr",
                            "it",
                            "es",
                            "gr",
                            "tr",
                            "de",
                            "nl",
                            "pt",
                            "hr",
                            "mt",
                            "ae",
                            "au",
                            "nz",
                            "th",
                            "sg",
                            "jp",
                            "br",
                            "mc",
                            "bs",
                            "cn",
                            "cy",
                            "me",
                            "tw",
                            "sx",
                            "pa",
                            "ag"
                        ],
                        "type": "string",
                        "description": "Filter listings to a specific country. Leave empty for worldwide results. Covers the 30 most-common YATCO listing countries — for any other country, paste a YATCO URL with `/country-<slug>/` instead."
                    },
                    "includeDetails": {
                        "title": "Include Full Detail Pages",
                        "type": "boolean",
                        "description": "When enabled, the actor visits each yacht's detail page for the full marketing description and the complete gallery of large images. Adds about 1–2 seconds per yacht. Disable for faster, cheaper runs that return only the search-card data.",
                        "default": true
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Per-run hard cap on rows across all queries and URLs combined. Default 1000 — set to 0 for no cap (be careful: the full YATCO catalog is 6000+ listings). The actor stops requesting new pages once this number is reached but keeps the full final page even if it slightly overshoots.",
                        "default": 1000
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
