# Boat & Yacht Listings Scraper for Yachtall (`haketa/yachtall-scraper`) Actor

Scrape boat & yacht listings from Yachtall: title, price, currency, year, boat type & category, length, cabins, fuel, location, seller and photos. For marine market research, pricing and dealer leads. Independent tool, not affiliated with Yachtall.

- **URL**: https://apify.com/haketa/yachtall-scraper.md
- **Developed by:** [Haketa](https://apify.com/haketa) (community)
- **Categories:** E-commerce, Lead generation
- **Features:** Limited permissions
- **Stats:** 1 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Boat & Yacht Listings Scraper for Yachtall ⛵ — Marine Market Data Extractor

[![Apify Actor](https://img.shields.io/badge/Apify-Actor-orange?style=flat-square\&logo=apify)](https://apify.com/haketa/yachtall-scraper)
[![Data Format: JSON / CSV / Excel](https://img.shields.io/badge/Format-JSON%20%7C%20CSV%20%7C%20Excel-blue?style=flat-square)](#)
[![Pagination: 1,000+ Deep](https://img.shields.io/badge/Pagination-1%2C000%2B%20Deep-brightgreen?style=flat-square)](#)
[![Maintenance: Active](https://img.shields.io/badge/Maintenance-Active-success?style=flat-square)](#)
[![Proxy: Datacenter Friendly](https://img.shields.io/badge/Proxy-Datacenter%20Friendly-green?style=flat-square)](#)

Extract comprehensive boat and yacht listings from [Yachtall](https://www.yachtall.com) — one of Europe's largest international marine marketplaces — at scale, with no login and no coding required. This **Yachtall scraper** collects full vessel specifications, including **asking price, currency, year built, boat type (sailboat, powerboat), category, length, beam, draught, hull material, cabins, fuel, mooring location, high-resolution photo, and selling dealer or broker with their named contact person**.

Leave the input empty to scrape all featured boats, or paste specific category and search URLs (e.g. `/en/sailboats`, `/en/motorboats`, or custom filtered searches). With unlocked 1,000+ pagination, you can extract thousands of boat listings directly into **JSON, CSV, Excel, or API**.

***

### ⚡ At a glance

| Feature | Detail |
|---|---|
| **Target Website** | [Yachtall](https://www.yachtall.com/) (International Boat & Yacht Marketplace) |
| **Output Formats** | JSON, CSV, Excel (XLSX), XML, HTML Table, RSS |
| **Key Data Fields** | Boat Name, Price, Currency, Year Built, Type, Length (m), Cabins, Location, Broker/Seller, Contact Person, Photos |
| **Pagination & Depth** | Unlocked 1,000+ deep pagination across consecutive search pages (`?pg=N`) |
| **Authentication** | None required (No cookies, no API key, no account needed) |
| **Average Speed** | ~40–60 enriched boat listings per minute |
| **Proxy Requirement** | Datacenter proxy friendly (Cost-effective out of the box) |
| **Integrations** | Webhooks, Zapier, Make, Google Sheets, Airbyte, Python, Node.js, cURL |

***

### 🔎 Why scrape Yachtall?

[Yachtall](https://www.yachtall.com) lists over 25,000 boats and yachts from professional brokers, shipyards, and private sellers across Germany, the Netherlands, Italy, France, Spain, Croatia, the UK, and international waters. Each listing represents a comprehensive marine asset dossier: an asking price, structural specifications (hull material, draft, beam), propulsion details (engine, fuel), interior accommodations (cabins, berths), and verified broker contact details.

That data is indispensable for the global maritime industry:

- **Marine Market Valuation & Residual Value**: Benchmark asking prices by boat type, shipyard, hull length, and manufacturing year to build accurate appraisal models.
- **Broker & Dealer Lead Generation**: Every listing identifies the selling marine brokerage and frequently names the individual sales representative.
- **Inventory & Supply Intelligence**: Track which boat classes (catamarans, trawlers, motor yachts, sailing yachts) are surging or depreciating across regional marinas.
- **Finance & Marine Insurance Prospecting**: Source recently listed vessels to price yacht loans, warranty products, and marine insurance policies.

Manually navigating boat listings and copying technical specifications across individual tabs is unviable. This **Yachtall data extractor** automates the entire discovery, pagination, and detail enrichment pipeline.

***

### 💼 Core Use Cases & Applications

#### 1. Marine Brokerage Lead Generation

Discover active yacht brokers, dealerships, and charter companies across Europe. Extract business names, contact persons, and inventory portfolios to build high-value B2B partner directories.

#### 2. Vessel Valuation & Price Benchmarking

Calculate real market asking prices for specific hull lengths (e.g. 12m to 15m) and vintage brackets (e.g. 2015–2022). Identify undervalued boats listed below market equilibrium for yacht flipping or brokerage mandates.

#### 3. Marine Insurance & Surveying

Gather historical comparable sales data for yacht surveyors, loss adjusters, and marine underwriters assessing replacement value and damage risks.

#### 4. Marine Equipment & Refit Suppliers

Target owners and dealers of specific boat categories (e.g., steel hulls, multihulls, diesel trawlers) with tailored refit services, rigging hardware, electronics, and marine coatings.

#### 5. PropTech & Marine Market Intelligence

Power marine listing aggregator portals, mobile apps, and investment dashboards with real-time boat inventory feeds.

***

### ⛵ Covered Boat Types & Categories

This scraper extracts listings across all boat classifications indexed on Yachtall:

- ⛵ **Sailing Boats & Yachts**: Cruisers, Daysailers, Catamarans, Trimarans, Regatta / Racing Yachts, Motorsailers, Gulets, Wooden Classics
- 🛥️ **Motorboats & Power Yachts**: Flybridge Yachts, Hardtop / Open Cruisers, Trawlers, Sportsboats, Ribs / Inflatables, Cabin Cruisers, Mega Yachts
- 🚤 **Small Craft & Specialized Vessels**: Fishing Boats, Houseboats, Commercial Vessels, Electric Boats, Dinghies

***

### 📊 Extracted Data Fields

Every listing is cleaned, typed, and normalized. Here is the full data schema:

#### 🛳️ Listing & Specification Fields

| Field Name | Type | Coverage | Description |
|---|---|---|---|
| `boatId` | String | 🟢 High (100%) | Unique Yachtall listing identifier (e.g. `s312456`) |
| `title` | String | 🟢 High (100%) | Vessel name / model headline (e.g. `Bavaria Cruiser 46`) |
| `brand` | String | 🟢 High (95%) | Shipyard or manufacturer brand (e.g. `Bavaria`, `Beneteau`, `Sunseeker`) |
| `price` | Number | 🟢 High (92%) | Asking price parsed as a clean numeric value (e.g. `245000`) |
| `currency` | String | 🟢 High (92%) | Currency code (e.g. `EUR`, `USD`, `GBP`, `CHF`) |
| `condition` | String | 🟢 High (90%) | Vessel condition (`used` or `new`) |
| `yearBuilt` | Number | 🟢 High (90%) | Construction / launch year (e.g. `2018`) |
| `boatType` | String | 🟢 High (98%) | Primary propulsion classification (`sailboat`, `powerboat`) |
| `boatCategory` | String | 🟢 High (92%) | Specific vessel category (e.g. `cruiser`, `flybridge`, `catamaran`) |
| `lengthMeters` | Number | 🟢 High (94%) | Overall length parsed in metric meters (e.g. `14.27`) |
| `lengthRaw` | String | 🟢 High (94%) | Raw length string as provided (e.g. `14.27 m / 46.82 ft`) |
| `beamRaw` | String | 🟢 High (88%) | Beam / width measurement (e.g. `4.35 m`) |
| `draughtRaw` | String | 🟡 Conditional (75%) | Draft / depth measurement (e.g. `2.10 m`) |
| `hullMaterial` | String | 🟢 High (85%) | Hull construction material (e.g. `GRP`, `steel`, `aluminium`, `wood`) |
| `cabins` | Number | 🟡 Conditional (80%) | Number of passenger / guest cabins |
| `fuel` | String | 🟢 High (85%) | Fuel type (e.g. `diesel`, `petrol`, `electric`) |
| `conditionDetail`| String | 🟢 High (85%) | Descriptive condition notes |
| `location` | String | 🟢 High (96%) | Geographic location / mooring country & marina |
| `seller` | String | 🟢 High (98%) | Marine brokerage, dealership, or private seller name |
| `sellerContact` | String | 🟡 Conditional (75%) | Named broker contact person or sales advisor |
| `image` | String | 🟢 High (95%) | Primary high-resolution photograph URL |
| `description` | String | 🟢 High (90%) | Descriptive text snippet detailing equipment and refits |
| `listingUrl` | String | 🟢 High (100%) | Direct canonical URL to the listing on Yachtall |
| `scrapedAt` | String | 🟢 High (100%) | ISO-8601 extraction timestamp |

***

### ⚙️ Input Parameters

Configure the scraper easily using the Apify Console or API:

| Parameter | Type | Default | Description |
|---|---|---|---|
| `startUrls` | Array of Strings | `["https://www.yachtall.com/en/boats"]` | List of Yachtall listing or category URLs (e.g. `/en/boats`, `/en/sailboats`, `/en/motorboats`, or a filtered search URL). |
| `includeDetails` | Boolean | `true` | Fetch each boat's detail page for complete price, technical specs, and broker contact data. Turn off for ultra-fast title+URL indexing. |
| `maxItems` | Integer | `0` | Maximum vessels to collect across all URLs (`0` = unlimited). Prefilled at `60` for rapid exploratory tests. |
| `maxPages` | Integer | `0` | Maximum consecutive search pages to paginate per URL (`0` = unlimited, governed by `maxItems`). |
| `proxyConfiguration` | Object | Datacenter | Apify proxy configuration. Datacenter proxies deliver optimal speed and cost efficiency out of the box. |

***

### 📦 Example Output

Here is a representative JSON record returned by the actor:

```json
{
  "boatId": "s284910",
  "title": "Bavaria Cruiser 46 Style",
  "brand": "Bavaria",
  "price": 289000,
  "currency": "EUR",
  "condition": "used",
  "yearBuilt": 2019,
  "boatType": "sailboat",
  "boatCategory": "sailing yacht",
  "lengthMeters": 14.27,
  "lengthRaw": "14.27 m (46.82 ft)",
  "beamRaw": "4.35 m",
  "draughtRaw": "2.10 m",
  "hullMaterial": "GRP",
  "cabins": 3,
  "fuel": "diesel",
  "location": "Croatia, Split Marina",
  "seller": "Adria Marine Brokerage",
  "sellerContact": "Marko Horvat",
  "image": "https://img.yachtall.com/boats/28/49/10/bavaria-cruiser-46-main.jpg",
  "description": "Excellently maintained Bavaria Cruiser 46 Style in 3-cabin owner layout. Equipped with bow thruster, furling mainsail, teak cockpit, Garmin navigation pack, heating and solar panels.",
  "listingUrl": "https://www.yachtall.com/en/boat/bavaria-cruiser-46-style-s284910",
  "scrapedAt": "2026-11-10T13:20:00.000Z"
}
```

***

### 🔄 Comparison: Yachtall Scraper vs. Alternatives

| Feature / Capability | Yachtall Scraper | Manual Search & Copy | Generic Web Scraper |
|---|---|---|---|
| **Speed & Throughput** | ~50 boats / min (with specs) | 1 boat / 4 min | Slow and fragile |
| **Technical Specifications** | Structured JSON-LD extraction | Manual copying | Unstructured text snippets |
| **Seller & Broker Contact** | Normalized company & contact | Hard to parse | Often missing |
| **1,000+ Deep Pagination** | Unlocked deep `?pg=N` traversal | Impractical | Blocked after 2-3 pages |
| **Cost Efficiency** | Pure HTTP (Datacenter friendly) | High labor cost | Heavy browser overhead |
| **De-duplication** | In-memory ID tracking | High human error | Duplicate items across pages |

***

### 💻 How to Use via API

You can trigger runs programmatically using the Apify API and official SDKs:

#### Python Example

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

run_input = {
    "startUrls": ["https://www.yachtall.com/en/sailboats"],
    "includeDetails": True,
    "maxItems": 100,
    "maxPages": 0
}

run = client.actor("haketa/yachtall-scraper").call(run_input=run_input)

## Fetch dataset items
items = client.dataset(run["defaultDatasetId"]).list_items().items
for boat in items:
    print(f"{boat['title']} ({boat['yearBuilt']}) - {boat['price']} {boat['currency']} | Location: {boat['location']}")
```

#### Node.js Example

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

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });

const input = {
    startUrls: ['https://www.yachtall.com/en/motorboats'],
    includeDetails: true,
    maxItems: 50,
    maxPages: 0
};

const run = await client.actor('haketa/yachtall-scraper').call(input);
const { items } = await client.dataset(run.defaultDatasetId).listItems();

console.log(`Successfully scraped ${items.length} motor yachts!`);
```

#### cURL Example

```bash
curl "https://api.apify.com/v2/acts/haketa~yachtall-scraper/runs?token=YOUR_APIFY_TOKEN" \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{
    "startUrls": ["https://www.yachtall.com/en/boats"],
    "includeDetails": true,
    "maxItems": 60
  }'
```

***

### 📈 Analyzing Marine Market Data with Pandas

Once your dataset is downloaded, you can load it into Pandas for fast exploratory analysis and pricing models:

```python
import pandas as pd

## Load dataset CSV exported from Apify
df = pd.read_csv("yachtall_boats.csv")

## Filter boats with valid price and length
valid_boats = df.dropna(subset=["price", "lengthMeters", "yearBuilt"])

print("Price Statistics (€):")
print(valid_boats["price"].describe())

## Median asking price by boat type and category
pricing_summary = valid_boats.groupby(["boatType", "yearBuilt"])["price"].median()
print("\nMedian Price by Type and Vintage:")
print(pricing_summary.tail(15))

## Top boat brokers by inventory volume
top_brokers = df["seller"].value_counts().head(10)
print("\nTop Active Brokers:")
print(top_brokers)
```

***

### 💡 Best Practices & Pro Tips

1. **Lightweight Indexing First**: If you only need vessel names and listing URLs, set `includeDetails: false`. The scraper runs at maximum speed (~300 boats per minute).
2. **Category-Specific Crawls**: For targeted research, paste filtered category URLs (e.g. catamarans or flybridge cruisers in the Mediterranean) into `startUrls`.
3. **Empty Run Exploration**: Running with default `{}` automatically crawls recent featured vessels on Yachtall.
4. **Scheduled Price Monitoring**: Set up recurring monthly schedules to identify seasonal boat price drops across European marinas.
5. **Deduplication**: Built-in set tracking prevents duplicate boats from being saved if listings shift between pages during scraping.

***

### ❓ Frequently Asked Questions (FAQ)

##### Do I need a Yachtall account or premium subscription?

No. The scraper gathers publicly available listing data without requiring any login credentials, session cookies, or Yachtall membership.

##### Can I scrape specific boat brands (e.g., Sunseeker, Bavaria, Beneteau)?

Yes. Perform your search directly on Yachtall, apply filters for shipyard brand, length, price, or location, and copy the resulting search URL into `startUrls`.

##### Does the scraper run on Datacenter proxies?

Yes. Yachtall pages load reliably using Apify's standard Datacenter proxy infrastructure, keeping compute and bandwidth costs minimal.

##### What does setting maxPages to 0 do?

Setting `maxPages` to `0` enables automatic unlimited pagination. The scraper will continue requesting subsequent pages (`?pg=2`, `?pg=3`, etc.) until your requested `maxItems` quota is satisfied or the category ends.

##### Can I export directly to Excel or CSV?

Yes. From the Apify Console dataset view or via API, you can export your records directly as an `.xlsx` file, `.csv`, or automatically synchronize with Google Sheets.

***

### 🗺️ Key Marine Regions Covered

This actor extracts boats across all major European and international sailing regions:

- 🌊 **Mediterranean Sea**: Côte d'Azur (France), Balearic Islands & Costa Brava (Spain), Liguria & Sardinia (Italy), Greek Aegean Islands, Turkish Turquoise Coast
- 🏝️ **Adriatic Sea**: Dalmatian Coast, Split, Dubrovnik, Zadar, Istrian Peninsula (Croatia), Venice & Rimini (Italy), Kotor (Montenegro)
- ⚓ **North & Baltic Seas**: Kiel Fjord, Flensburg, Hamburg (Germany), IJsselmeer & Zeeland (Netherlands), Stockholm Archipelago & Gothenburg (Sweden), Denmark
- ⛵ **Atlantic & English Channel**: Solent, Southampton, Plymouth (UK), Brittany & Arcachon (France), Lisbon & Algarve (Portugal), Canary Islands
- 🏞️ **Inland Waterways & Lakes**: Lake Constance (Bodensee), Lake Geneva, Lake Maggiore, Lake Garda, Berlin / Brandenburg Lakes, Friesland Canals

***

### 🗄️ Database Storage: SQL / PostgreSQL Schema

For marine analytics teams storing listings in a relational data warehouse, here is an optimized schema with indexing for fast specification and pricing queries:

```sql
CREATE TABLE yachtall_boats (
    boat_id VARCHAR(32) PRIMARY KEY,
    title TEXT NOT NULL,
    brand VARCHAR(128),
    price NUMERIC(14, 2),
    currency VARCHAR(8) DEFAULT 'EUR',
    condition VARCHAR(16), -- new | used
    year_built INTEGER,
    boat_type VARCHAR(32), -- sailboat | powerboat
    boat_category VARCHAR(64),
    length_meters NUMERIC(6, 2),
    beam_raw VARCHAR(64),
    draught_raw VARCHAR(64),
    hull_material VARCHAR(64),
    cabins INTEGER,
    fuel VARCHAR(32),
    location TEXT,
    seller TEXT,
    seller_contact TEXT,
    image_url TEXT,
    description TEXT,
    listing_url TEXT NOT NULL,
    scraped_at TIMESTAMPTZ DEFAULT NOW()
);

-- Indexing for valuation models and comparable market searches
CREATE INDEX idx_yachtall_type_year ON yachtall_boats (boat_type, year_built);
CREATE INDEX idx_yachtall_price ON yachtall_boats (price, currency);
CREATE INDEX idx_yachtall_length ON yachtall_boats (length_meters);
CREATE INDEX idx_yachtall_seller ON yachtall_boats (seller);
```

***

### 🔄 Automated Workflows & CRM Sync

Connect your scraped yacht listings directly with your operational stack:

- **CRM Ingestion**: Automatically route new broker contacts into Salesforce, HubSpot, or Pipedrive via Apify Webhooks.
- **Instant Alerts**: Trigger Slack or Telegram notifications whenever a new boat under a specific price threshold appears in your target marina.
- **Automated Spreadsheet Refresh**: Sync new listings directly into Google Sheets or Airtable using the Apify Zapier / Make integration.
- **Data Lake Sync**: Ingest raw JSON batches directly into AWS S3, Google Cloud Storage, or Snowflake for longitudinal trend analysis.

***

### ⚖️ Disclaimer

This actor is an independent data extraction tool developed for market research and public intelligence purposes. It is not affiliated with, endorsed by, or sponsored by Yachtall or its operating entities. All product and brand names are trademarks of their respective holders.

***

### 📋 Changelog

#### Version 1.2 (2026-11)

- **Deep 1,000+ Pagination**: Set `maxPages` default to `0` (`minimum: 0`) and enabled deep multi-page traversal (`?pg=N`) governed by `maxItems`.
- **Enhanced Spec Normalization**: Standardized length in meters parsing and refined seller contact splitting.
- **Optimized Prefill Execution**: Fast prefill configuration completing in under 60 seconds with full technical specifications.
- **Expanded Documentation**: Complete field coverage indicators, pandas analytics recipes, and API examples.

#### Version 1.1

- Added parallel detail fetching with concurrency pooling.
- Added broker and contact person parsing (`parseSeller`).
- Mirrored output to Key-Value Store `OUTPUT` record for synchronous calls.

#### Version 1.0

- Initial public release supporting boat search URLs, JSON-LD spec extraction, and multi-format exports.

# Changelog

This Actor's version history is a separate document: https://apify.com/haketa/yachtall-scraper/changelog.md

# Actor input Schema

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

Yachtall listing/category/search URLs (e.g. https://www.yachtall.com/en/boats, /en/sailboats, /en/motorboats, or a filtered search URL). Defaults to all boats if empty.

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

Fetch each boat's detail page for price, currency, condition, boat type/category, length, beam, cabins, fuel, location and seller. Recommended — price lives on the detail page. Turn off for a fast title+URL-only list.

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

Maximum boats to return across all URLs. 0 = unlimited.

## `maxPages` (type: `integer`):

Maximum result pages to paginate per listing URL (15 boats per page). 0 = unlimited, governed by Max boats.

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

Apify Proxy. Datacenter is enough for Yachtall and is enabled by default.

## Actor input object example

```json
{
  "startUrls": [
    "https://www.yachtall.com/en/boats"
  ],
  "includeDetails": true,
  "maxItems": 60,
  "maxPages": 0,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `boatId` (type: `string`):

Yachtall boat ID

## `title` (type: `string`):

Boat name/title

## `brand` (type: `string`):

Manufacturer/brand

## `price` (type: `string`):

Asking price

## `currency` (type: `string`):

Currency code

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

new / used

## `yearBuilt` (type: `string`):

Year built

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

powerboat / sailboat

## `boatCategory` (type: `string`):

Boat category

## `lengthMeters` (type: `string`):

Length in meters

## `lengthRaw` (type: `string`):

Length (raw text)

## `beamRaw` (type: `string`):

Beam (raw text)

## `draughtRaw` (type: `string`):

Draught / draft (raw text)

## `hullMaterial` (type: `string`):

Hull material (e.g. GRP, steel)

## `cabins` (type: `string`):

Number of cabins

## `fuel` (type: `string`):

Fuel type

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

Boat location

## `seller` (type: `string`):

Seller / dealer

## `sellerContact` (type: `string`):

Seller contact person

## `image` (type: `string`):

Main image URL

## `description` (type: `string`):

Listing description

## `listingUrl` (type: `string`):

Listing URL

## `scrapedAt` (type: `string`):

ISO timestamp

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "startUrls": [
        "https://www.yachtall.com/en/boats"
    ],
    "includeDetails": true,
    "maxItems": 60,
    "maxPages": 0,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("haketa/yachtall-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "startUrls": ["https://www.yachtall.com/en/boats"],
    "includeDetails": True,
    "maxItems": 60,
    "maxPages": 0,
    "proxyConfiguration": { "useApifyProxy": True },
}

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

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

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

```

## CLI example

```bash
echo '{
  "startUrls": [
    "https://www.yachtall.com/en/boats"
  ],
  "includeDetails": true,
  "maxItems": 60,
  "maxPages": 0,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call haketa/yachtall-scraper --silent --output-dataset

```

## MCP server setup

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

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

## OpenAPI specification

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