Yachtall Scraper — Boat & Yacht Listings with Price, Specs, Location & Seller

This Yachtall scraper extracts boat and yacht listings from Yachtall at scale — title, asking price and currency, year built, boat type and category, length, beam, draught, hull material, cabins, fuel, location, main photo, and the selling dealer/broker with their contact person. Leave the input empty to scrape every boat, or paste category and search URLs — no login, no coding, clean data in seconds. The actor is pure-HTTP with a browser-grade fingerprint, so it is fast and cheap: no headless browser and no residential proxy required.

Export every result to JSON, CSV, Excel, or API.

Built for marine market analysts, boat dealers and brokers, yacht-finance and insurance teams, surveyors, used-boat traders, data engineers and lead-generation agencies who need structured Yachtall data instead of copy-pasting listings by hand.

---

🔎 Why scrape Yachtall?

Yachtall is one of the largest international boat and yacht marketplaces, carrying tens of thousands of power and sail listings from dealers, brokers and private sellers across Europe and beyond. Each listing is a rich record: an asking price, detailed specifications (length, beam, draught, hull material, cabins, fuel, year), a location where the boat lies, and the dealer or broker offering it. That combination — price + specifications + location + seller — is exactly what marine businesses need to understand the used-boat market.

Collecting it by hand is slow and error-prone. The specs live on each boat's detail page, prices change, listings appear and disappear daily, and there is no download button. Copy-pasting hundreds of boats into a spreadsheet is a non-starter when you want to benchmark a whole category or track a competitor's inventory over time.

This Yachtall scraper automates all of it. Point it at a category, a search, or the whole marketplace, and it paginates through every result, opens each boat's detail page, and returns a clean, de-duplicated, typed dataset you can analyze immediately.

Common reasons people scrape Yachtall:

• Price benchmarking — compare asking prices by boat type, brand, length, year and region to understand the used-boat market.
• Dealer and broker lead generation — every listing names the selling dealer/broker and a contact person, a targeted source of marine-industry leads.
• Inventory and competitor monitoring — track which boats are listed, at what prices, by whom, and where.
• Valuation and analytics — build price-vs-length-vs-year-vs-type models and spot under- or over-priced boats.
• Market research — size the supply of a category (e.g. sailing yachts, trawlers, motorboats) across countries.
• CRM and catalog enrichment — feed fresh listings, prices, specs and seller details into your own systems.
• Finance and insurance prospecting — reach boat owners, buyers and dealers with relevant offers.

✨ What this Yachtall scraper does

• ✅ Scrapes any Yachtall view — leave the input empty to scan all boats, or paste category URLs (/en/sailboats, /en/motorboats, /en/boats) or a full filtered search URL.
• ✅ Automatic pagination — follows the rel="next" link page by page (15 boats per page) and collects large, de-duplicated result sets of hundreds to thousands of boats, bounded by maxItems / maxPages.
• ✅ Rich per-boat fields — captures:
  • Identity & listing: boatId, title, brand, listingUrl, image, description
  • Pricing: price, currency, condition (new / used), availability
  • Specifications: boatType (powerboat / sailboat), boatCategory, yearBuilt, lengthMeters, lengthRaw, beamRaw, draughtRaw, hullMaterial, cabins, fuel, conditionDetail, newOrUsed
  • Location & seller: location, seller (dealer/broker), sellerContact (contact person)
• ✅ Typed, structured specs — length, beam, draught, cabins, fuel, type and category are parsed from the listing's own JSON-LD structured data, not scraped from free text.
• ✅ Fast, title-only mode — turn includeDetails off for a quick list of titles and listing URLs when you don't need the full detail pages.
• ✅ Export anywhere — JSON, CSV, Excel, HTML, or via the Apify API; push to Google Sheets, a webhook, Make, Zapier or a database.
• ✅ Fast & reliable — pure-HTTP with a Chrome-grade TLS fingerprint, automatic retries with proxy rotation, and parallel detail fetching. Datacenter proxy is enough.

🎯 Use cases

• Marine market analysts — benchmark asking prices, lengths and specs across types, brands, years and regions to map the used-boat market.
• Boat dealers & brokers — monitor competing inventory and pricing, and discover other brokers as partners or leads.
• Yacht finance & insurance teams — build prospect lists of owners, buyers and dealers and enrich them with boat specs and values.
• Marine surveyors & appraisers — pull comparable listings (by length, year, type) to support valuations.
• Used-boat traders & flippers — spot under-priced listings and track price movements over time.
• Equipment & refit suppliers — reach dealers and owners of specific boat types, lengths or hull materials.
• Data engineers & agencies — deliver a clean Yachtall data feed into a client's CRM, data warehouse or analytics stack.
• Researchers & journalists — study marine-market supply, pricing trends and regional concentration.

📥 Input

Configure the actor with a few simple parameters. Leave startUrls empty to scrape all boats, or paste one or more Yachtall URLs.

Field	Type	Description
startUrls	array	Yachtall listing / category / search URLs (e.g. https://www.yachtall.com/en/boats, /en/sailboats, /en/motorboats, or a filtered search URL). Empty = all boats.
includeDetails	boolean	Fetch each boat's detail page for price, currency, condition, boat type/category, length, beam, draught, hull material, cabins, fuel, location and seller. Default true (price lives on the detail page). Turn off for a fast title + URL-only list.
maxItems	integer	Maximum boats to return across all URLs. 0 = no limit.
maxPages	integer	Maximum result pages to paginate per listing URL (15 boats per page). Default 50.
proxyConfiguration	object	Apify Proxy settings. Datacenter is enough for Yachtall and is enabled by default.

Example input

{
  "startUrls": ["https://www.yachtall.com/en/motorboats"],
  "includeDetails": true,
  "maxItems": 300,
  "maxPages": 20,
  "proxyConfiguration": { "useApifyProxy": true }
}

📤 Output

Each boat is one clean record. Fields sourced from the detail page (price, specs, location, seller) appear when includeDetails is on; some specs populate only when the seller provided them (see note below).

{
  "boatId": "s265055",
  "title": "Sunrise Holländischer Deckshausyacht",
  "brand": "Sunrise",
  "price": 490000,
  "currency": "EUR",
  "condition": "used",
  "availability": "InStock",
  "yearBuilt": 1998,
  "boatType": "sailboat",
  "boatCategory": "sailing yacht",
  "lengthMeters": 18.88,
  "lengthRaw": "18.88 m (62 feet)",
  "beamRaw": "4.88 m (16 feet)",
  "draughtRaw": "2.20 m (7.2 feet)",
  "hullMaterial": "steel",
  "cabins": 2,
  "fuel": "diesel",
  "conditionDetail": "good",
  "newOrUsed": "used boat",
  "location": "Bar / Tivat, Montenegro",
  "seller": "Quiotek Consulting",
  "sellerContact": "Mr. Boris Quiotek",
  "description": "The S/Y Caledonia was built between 1998 and 2000 in Makkum, the Netherlands...",
  "image": "https://image.yachtall.com/image/sboat/0/265/055/huge-4jgsrgn2f7.jpg",
  "listingUrl": "https://www.yachtall.com/en/boat/sunrise-hollaendischer-deckshausyacht-s265055",
  "scrapedAt": "2026-09-28T13:24:31.985Z"
}

Field reference

Field	Description
boatId	Yachtall boat ID (used for de-duplication).
title	Boat name / listing title.
brand	Manufacturer / brand.
price	Asking price (number). Present when available.
currency	Currency code (e.g. EUR, USD, GBP).
condition	new or used.
availability	Listing availability (e.g. InStock).
yearBuilt	Year the boat was built.
boatType	powerboat or sailboat.
boatCategory	Boat category (e.g. sailing yacht, motor yacht, trawler).
lengthMeters	Length in meters (number).
lengthRaw	Length as shown on the listing (raw text).
beamRaw	Beam / width (raw text).
draughtRaw	Draught / draft — how deep the boat sits (raw text). Present when provided.
hullMaterial	Hull material (e.g. GRP/polyester, steel, aluminium). Present when provided.
cabins	Number of cabins (number).
fuel	Fuel type (e.g. diesel, petrol).
conditionDetail	Finer condition note from the detail page.
newOrUsed	"new boat" / "used boat" label from the listing.
location	Where the boat lies (city / region / country).
seller	Selling dealer / broker.
sellerContact	Named contact person for the seller.
description	Listing description (trimmed).
image	Main photo URL.
listingUrl	Canonical Yachtall listing URL.
scrapedAt	ISO timestamp of when the record was scraped.

Note on coverage: core fields (title, listingUrl, brand, price, currency, boatType, location, seller) are present on virtually every boat. Optional specs such as draughtRaw, hullMaterial, beamRaw and cabins populate only when the seller filled them in, so they appear on a subset of listings — this is expected marketplace data, not a scraping error. Without includeDetails, each record contains only boatId, title and listingUrl (fast mode).

🔁 Pagination & scale

The Yachtall scraper paginates automatically. For each start URL it reads the listing page, extracts the 15 boats on it, follows the rel="next" link (?pg=N) to the next page, and repeats until there are no more pages. Every boatId is de-duplicated across all pages and URLs, so you never get repeats even when categories overlap.

Scale is controlled by two inputs:

• maxItems — a hard cap on total boats across all URLs (0 = no limit, paginate to the end).
• maxPages — a per-URL page cap (15 boats per page; default 50 pages ≈ 750 boats per URL).

This lets you pull anything from a quick sample of 60 boats to many thousands across an entire category. Detail pages are fetched in parallel batches for speed, and every request is retried with proxy rotation on transient errors.

⚙️ How to use

1. Open the actor on the Apify Console.
2. Set startUrls — leave empty for all boats, or paste category/search URLs (e.g. https://www.yachtall.com/en/sailboats).
3. Keep includeDetails on for price, specs, location and seller (turn it off only for a fast title+URL list).
4. Set maxItems / maxPages to control how many boats you collect.
5. Click Start. Watch the live log and status as boats stream into the dataset.
6. Export the results as JSON, CSV, Excel or HTML, or pull them via the Apify API.
7. Automate it — run on a Schedule to track new listings and price changes, or wire the output to Make, Zapier, Google Sheets, a webhook or a database.

Run via API (Python)

from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

run_input = {
    "startUrls": ["https://www.yachtall.com/en/motorboats"],
    "includeDetails": True,
    "maxItems": 300,
}

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

for b in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(b["title"], "·", b["price"], b["currency"], "·", b["lengthRaw"], "·", b["location"])

Build a dealer lead list (Node.js)

import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });

const run = await client.actor('haketa/yachtall-scraper').call({
    startUrls: ['https://www.yachtall.com/en/boats'],
    maxItems: 500,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
const dealers = {};
for (const b of items) if (b.seller) dealers[b.seller] = (dealers[b.seller] || 0) + 1;
console.log(Object.entries(dealers).sort((a, b) => b[1] - a[1]).slice(0, 20));

💡 Tips

• All boats vs. a category: leave startUrls empty to scan everything, or use /en/sailboats, /en/motorboats or any filtered search URL to focus on one segment.
• includeDetails is where the value is — price, specs, location and seller all come from the detail page. Keep it on unless you only need a URL list.
• maxItems: 0 paginates to the very end of a category (15 boats per page).
• Benchmark by type: group the output by boatType or boatCategory and take the median price to compare segments.
• Build lead lists: aggregate by seller / sellerContact to find the most active dealers and brokers.
• Schedule it to capture new listings and price drops over time and build a historical price series.

❓ FAQ

Is scraping Yachtall legal? The actor collects only publicly visible listing information — no login or account is required. You are responsible for how you use the data; respect Yachtall's Terms of Service and applicable data-protection laws, especially when handling seller contact details.

Do I need to log in or provide credentials? No. The Yachtall scraper reads public listing pages. No account, no cookies, no credentials.

Do I need proxies or a residential proxy? No residential proxy is needed. Yachtall serves plain SSR HTML with no aggressive anti-bot, so a datacenter proxy (enabled by default) is enough. The actor uses a Chrome-grade TLS fingerprint and retries with rotation.

How many boats can it return, and how fast? As many as the category contains — hundreds to thousands — bounded by your maxItems / maxPages. It paginates 15 boats per page and fetches detail pages in parallel, so a few hundred boats complete in well under a minute.

Where does the price come from? From each boat's detail page (JSON-LD structured data). Keep includeDetails on to capture price, currency, specs, location and seller.

Which currencies appear? Whatever the seller listed — commonly EUR, but also USD, GBP and others. Each record carries its own currency code.

Why are some fields (draught, hull material, cabins) empty on some boats? Those specs are optional on Yachtall and only appear when the seller filled them in. Core fields (title, price, type, location, seller) are present on virtually every listing; optional specs populate on a subset.

Can I filter by boat type or search terms? Yes — build the filter on Yachtall itself (choose a category or run a search) and paste the resulting URL into startUrls. The actor scrapes exactly that view, including all its pages.

What export formats are supported? JSON, CSV, Excel, HTML, or via the Apify API — plus Google Sheets, webhooks, Make and Zapier integrations.

Is there a Yachtall API? There is no official public Yachtall API for bulk listing data. This actor is the practical way to get a structured Yachtall data feed, and it exposes its own results through the Apify API.

How fresh is the data? Every run scrapes Yachtall live, so results reflect the listings at the moment you run it. Schedule the actor to keep a continuously updated dataset.

🔗 Related scrapers

Building a travel, events or lead-generation dataset? Try these other scrapers:

• Luma Event Scraper
• Meetup Scraper
• Expedia Scraper
• HRS Hotel Scraper
• Eventbrite Scraper
• Furnished Finder Scraper

---

Legal & responsible use

This actor is an independent tool and is not affiliated with, endorsed by, or sponsored by Yachtall or its operators. All trademarks are the property of their respective owners. It collects only publicly available listing information for research and business use. Please respect Yachtall's Terms of Service and robots directives, comply with applicable data-protection laws when handling seller contact details, use reasonable request volumes, and do not use the data for spam, harassment or any unlawful purpose.

---

Ready to pull structured boat & yacht data? Click Start to run the Yachtall scraper and export price, specs, location and seller for every listing to JSON, CSV, Excel or API.