# Nettivene Scraper: Finland Boats, Sailboats, Jet Skis, Engines (`recordsdata/nettivene-scraper`) Actor

Scrape nettivene.com, the Finnish boat marketplace: motor boats, sailboats, jet skis, engines and 20 more types with prices, make, model, year, length, engine hours and power, photos, seller type, plus the sold archive and 235 dealers. No login, no proxy. Export JSON, CSV or Excel.

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

## Pricing

from $22.00 / 1,000 boat ads

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/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

![RecordsData](https://api.apify.com/v2/key-value-stores/AAm3a1h3Z9nYfrvh9/records/banner?v=3)

## Nettivene Scraper: Boat, Sailboat, Jet Ski and Boat Engine Listings from nettivene.com (Finland)

> Nettivene Scraper is an Apify Actor that extracts boat listings from nettivene.com, the Finnish boat marketplace: motor boats, sailboats, jet skis, engines and 20 more types, with EUR prices, make, model, year, length, engine data and dealer details. On 2026-10-23 the site listed 9,905 boats for sale. Export JSON, CSV or Excel, no login, no proxy.

The actor reads the pages the site shows to visitors, at a gentle pace. The site applies the filters itself, so a search for Buster boats from 2015 to 2020 under 25,000 EUR returns exactly those ads.

### What can you scrape from Nettivene?

- **Boat listings**: 9,905 boats and engines for sale on 2026-10-23 across 24 boat types, newest first. Motor boats are the default (6,228 ads); sailboats (458), jet skis (851), engines (1,620), rowing boats, kayaks, RIB boats, hovercraft and the other types are one setting away.
- **Ad details** (on by default): the seller's text and one-line selling point, length, beam, draft, weight, mast height, berths, hull material, colour, engine make, model, power, hours and year, sails, winter storage, equipment list, number of owners, the full photo gallery and the last update date.
- **Sold archive**: 27,525 sold ads in all types on 2026-10-23, 18,534 of them motor boats, with the data the ad kept.
- **Dealers**: the directory of 235 boat dealers in 20 regions, with address, number of ads, website, logo and description.

### Why use this actor?

- **Real filters, applied by the site**: 52 input fields, from boat type, make, model, region and town to price, year, length, beam, weight, draft, berths, hull material, boat style, engine make, type, fuel, power, hours and year, 28 equipment items, seller type and 8 sort orders.
- **Whole catalogue reachable**: no depth cap was found. A test read all 6,228 motor boats for sale, page by page, with 6,228 unique ad numbers and no duplicates.
- **Light to run**: plain HTTP, no browser, no proxy. 32 of 32 cloud runs of 3 results passed in two batches, median 6.8 seconds, peak memory 42 to 65 MB.
- **Privacy built in**: private sellers are flagged with `isPrivateSeller` and never named, phoned or located. Phones, e-mails and plates are removed from their free text; dealer sales people are never read.

### How to scrape nettivene.com in four steps

1. Open the actor in Apify Console and choose **What to collect**.
2. Pick the **Boat types**, add makes such as `Buster` or `Yamarin` and the filters you need, or leave everything empty for the newest motor boats.
3. Set **Maximum items** and click **Start**.
4. Download the dataset from the **Storage** tab as JSON, CSV or Excel.

### Three ways to collect data

| Mode (`mode`) | Use it to | Rows |
|---|---|---|
| `search` | Find boats by type, make, model, place and the full filter set | `vehicle` |
| `urls` | Refresh known ads by number or address, read all ads of one dealer, replay a saved search of the site, or follow the newest-ads feed | `vehicle` |
| `dealers` | List the dealer directory by region, town or name, or read dealers by number | `dealer` |

A minimal example of a `search` run:

```json
{
  "mode": "search",
  "boatTypes": ["motor-boat"],
  "makes": ["Buster"],
  "minYear": 2015,
  "maxPrice": 25000,
  "sortBy": "price-asc",
  "maxItems": 100
}
```

Several boat types in one run are read one after the other in the order you list them. A dealer address given in `urls` mode returns all ads of that dealer, not the dealer row; use `dealers` mode for dealer rows.

### What data do you get?

Every row has a `recordType`: `vehicle` (a boat, a jet ski, an engine or another ad) or `dealer`. There are 67 output fields plus `error`. Fields the ad does not state are left out, never guessed. Free text such as the description and the equipment list stays in the language the seller wrote, mostly Finnish.

| Field | Description |
|---|---|
| `imageUrl`, `recordType`, `listingId`, `dealerId`, `url` | Cover photo or dealer logo, record type, ad number, dealer number, address |
| `sourceSite`, `country`, `listingType`, `listingStatus`, `vehicleType`, `subType` | `nettivene.com`, `FI`, `sale`, `for-sale` or `sold`, the boat type such as `motor-boat`, `sailboat`, `jet-ski`, `engine`, and the style such as `cabin`, `cruiser`, `bowrider` |
| `title`, `headline`, `description` | Ad title, the seller's one-line selling point and the seller's text |
| `price`, `currency`, `priceWithOfficeFee`, `officeFee`, `priceChange` | Advertised price in EUR, price with the dealer's office fee, `reduced` when the site shows a drop |
| `make`, `model`, `year` | Identity and age of the boat |
| `length`, `beam`, `draft`, `weight`, `mastHeight`, `berths` | Size in metres and kilograms, mast height of sailboats, number of berths |
| `hullMaterial`, `color` | `fibreglass`, `aluminium`, `wood`, `steel`, `plastic`, `concrete` or `carbon-fibre`; colour |
| `engineMake`, `engineModel`, `engineModelDetail`, `engineCount` | Engine make, model, detail line and number of engines |
| `engineType`, `engineStroke`, `fuelType`, `enginePower`, `engineHours`, `engineYear` | Outboard, inboard, stern-drive, electric or water-jet; 2-stroke or 4-stroke; fuel; horsepower; operating hours; engine model year |
| `shaftLength`, `cooling`, `sails`, `winterStorage`, `availability`, `warranty`, `owners` | Shaft length, cooling, one text per sail, winter storage, availability, warranty text, number of owners |
| `features` | Equipment list |
| `city`, `region`, `address` | Place of the boat; the street address of a dealer only |
| `images`, `imageCount`, `videoUrl`, `updatedAt` | Full-size photo links, photo count, video link, last update date |
| `sellerName`, `sellerUrl`, `sellerId`, `sellerWebsite`, `sellerPhone`, `isPrivateSeller` | Dealer identity, filled for dealers only; the phone only with **Dealer contact details** |
| `phone`, `adCount`, `website`, `logoUrl` | Dealer rows: business phone (only with **Dealer contact details**), number of ads, website, logo |
| `raw`, `scrapedAt`, `error` | Optional source objects, scrape time, and an error message when the input needed a fix |

Fill rates measured on 2026-10-23: in 6,228 list rows of motor boats, `price` is present in 98 percent, `year` in 90, `engineMake` in 93, `enginePower` in 84 and `city` in 99. In 40 ad pages across seven boat types, `description` and `region` are present in 100 percent and `length` in 70. Sellers state what they choose to state, so engines and rowing boats carry far fewer fields than sailboats.

#### Sample output

A real boat row from a run on 2026-10-23 (shortened):

```json
{
  "recordType": "vehicle",
  "listingId": "1055252",
  "url": "https://www.nettivene.com/moottorivene/amt/1055252",
  "listingStatus": "for-sale",
  "vehicleType": "motor-boat",
  "title": "AMT 210 DC",
  "headline": "Vain 75h ajettu sekä juuri huollettu!",
  "price": 44900,
  "currency": "EUR",
  "make": "AMT",
  "model": "210 DC",
  "year": 2020,
  "length": 6.3,
  "beam": 2.4,
  "berths": 2,
  "engineMake": "Honda",
  "engineModel": "BF 150",
  "engineType": "outboard",
  "engineStroke": "4-stroke",
  "fuelType": "petrol",
  "enginePower": 150,
  "engineHours": 75,
  "engineYear": 2020,
  "features": ["Jääkaappi", "Kaiku", "Karttaplotteri", "Kuomu", "Stereot", "Uimaportaat", "WC"],
  "city": "Varkaus",
  "region": "Pohjois-Savo",
  "imageCount": 11,
  "isPrivateSeller": true,
  "scrapedAt": "2026-10-23T23:16:10.650Z"
}
```

### Monitor new listings and repricing

Switch on **Only new listings (monitor mode)** and the actor remembers every ad it delivered, in a named key-value store of your own account (`nettivene-seen`). A scheduled run with the same filters returns only unseen ads and reads the newest-first list only until it meets known ones. A run with nothing new ends with an empty dataset. In a cloud test, a first run returned 3 hovercraft dealer ads and the second run returned none.

### How does Nettivene Scraper compare with other scrapers? (read on 2026-10-23)

No actor in the Apify Store targets nettivene.com; a search for "Nettivene" returns nothing. The nearest reference is `blackfalcondata/finn-mobility-scraper`, which reads Finn.no, the Norwegian marketplace, for cars, motorcycles, boats and more (1,708 runs and 9 users in 30 days). Boat-specific actors read other sites: `getascraper/yachtworld-scraper` (YachtWorld, 29 fields, 299 runs and 6 users in 30 days) and `mrdoe/boat24-scraper-actor` (boat24, 11 fields, 88 runs and 4 users in 30 days).

| | Nettivene Scraper | Finn.no Mobility Scraper | YachtWorld Boats Scraper |
|---|---|---|---|
| Site and country | nettivene.com, Finland, EUR | finn.no, Norway, all vehicles | yachtworld.com, boats worldwide |
| Published fields | 67 | 101 | 29 |
| Fields in common | 32 | 32 | n/a |
| Boat-only fields here | sub-type, hull material, draft, mast height, sails, winter storage, engine hours and year, shaft length, cooling, equipment list | n/a | n/a |
| Dealer directory, sold archive, monitor mode | yes | no | no |

Nettivene Scraper outputs no map coordinates, because the ad and dealer pages carry none, and no registration numbers. It adds the dealer directory, the sold archive, monitoring and the privacy rules. For Norwegian listings use the Finn.no actor, which this actor does not cover.

### Use with AI agents (MCP) and integrations

Call it from the Apify API, the JavaScript or Python client, Make, Zapier or n8n.

Connect the Apify MCP server to Claude or Cursor and this actor appears as a tool: `https://mcp.apify.com?tools=RecordsData/nettivene-scraper`.

Example prompt: "List the 20 cheapest sailboats from 1990 or newer with a draft under 1.5 metres, with price, length and dealer."

### Is it legal to scrape nettivene.com? Limits and responsible use

The actor reads public listing pages. It does not log in, solve captchas or bypass any protection, and it keeps a slow pace of about two requests per second. Two things are on record and you should weigh both before you collect data.

- **robots.txt**: for all robots it disallows only `/build/` and `/bundles/`, and it sets no crawl delay. Its header also reserves text and data mining rights under section 13 b of the Finnish Copyright Act, including training of AI and machine-learning systems, unless the owner agrees in writing beforehand.
- **Marketplace terms**: the terms of the site owner (Alma Media, almamedia.fi/markkinapaikkaehdot, read on 2026-10-23) forbid robots, spiders, scrapers and other automated retrieval of the service without the provider's prior express written consent (section 9). They also forbid collecting parts of the service into an own service or dataset, and commercial use of it (section 4).

You decide whether your use is allowed where you work and, if needed, ask the site owner for permission. Private sellers' names, phones and addresses and all registration numbers are not output.

Limits:

- A filter on a number that the ad does not state, such as length or engine hours, leaves out the ads that do not state it. Only 38 percent of the list rows state engine hours.
- List-card engine hours are rounded; keep **Read ad pages** on for the exact number.
- The site does not show whether a boat is unused, so there is no filter for it. It prints only the last update date of an ad, never the publication date, and no VAT flag was found on any boat ad.
- The dealer name search walks the directory page by page and takes about 35 seconds.
- Sold ads keep only the data the site still shows for them, so some fields are missing.

### Frequently Asked Questions

#### How do I scrape nettivene.com?

Open the actor, pick `search`, choose the boat types, add makes and filters, set **Maximum items** and press Start. Download one row per ad as JSON, CSV or Excel, or read it through the Apify API. No proxy, browser or site account is needed. A run of 3 results finishes in about 7 seconds, so you can test first.

#### Is it legal to scrape nettivene.com?

The actor reads public pages, does not log in and keeps a slow pace. Two flags are on record: the robots.txt reserves text and data mining rights under the Finnish Copyright Act, and the marketplace terms of the site owner forbid automated retrieval and building a dataset from the service without written consent. The legal section above explains both. You are responsible for deciding whether your use complies.

#### How is a run billed?

The actor is billed per event. A boat read from the search list only is one event, a boat with its ad page (the default) is a second, higher event, and a dealer is a third. Live rates are shown on the Pricing tab of the Store page. Error rows, empty searches and ads skipped by monitoring are never charged.

#### Which boats does it cover?

Motor boats by default, and with **Boat types** also sailboats, jet skis, engines, rowing boats, kayaks, RIB boats, hovercraft, trimarans and the rest of the 24 types of the site. 9,905 ads were for sale on 2026-10-23, 6,228 of them motor boats. The sold archive is reached with **Listing status** set to `sold`.

#### How many ads can I get in one run?

The site sets no cap that we could find, and the whole list is reachable page by page. A test read all 6,228 motor boats in 213 requests. Set `maxItems` to what you need. A scan stops after `maxScanSeconds`; split very large reads by boat type, make or region, and use monitor mode for follow-ups.

#### Can I find a boat by length, engine power or engine hours?

Yes. Length, beam, weight, draft, berths, engine power, engine hours, engine year and model year all have a minimum and a maximum. The filters are applied by the site and checked again on every row, so a boat outside the range is not delivered.

#### Can I get the seller's phone number?

Only the business phone of a dealer, and only when **Dealer contact details** is on; it costs one extra request per dealer and no extra event. Phone numbers of private sellers and names of dealer sales people are never read, and private rows carry `isPrivateSeller: true`.

#### Can I monitor new listings every day?

Yes. Turn on **Only new listings (monitor mode)**, keep the filters the same and schedule the actor. Each run returns only ads not delivered before, remembered in your own key-value store, and costs nothing when there is nothing new, so a daily schedule stays cheap.

#### What happens when the search finds nothing or the input is wrong?

A search with no hits ends as succeeded with an empty dataset and charges nothing. A wrong value, such as a minimum price above the maximum or a misspelled make, ends as succeeded with one free error row that explains the fix and suggests the closest names, so a typo never costs you money.

#### Does it work for Finnish text?

Yes. Titles, descriptions and equipment lists are returned as the seller wrote them, with Finnish and Swedish letters intact. Technical values such as engine type, fuel and hull material are normalised to English enums, so rows from different sellers compare cleanly and can be filtered in a spreadsheet.

#### Do I need a proxy?

No. The actor was measured from the Apify cloud without any proxy and used plain HTTP for every request: no request was retried or throttled in 32 runs. It does not use a browser either, which keeps a 3-result run near 7 seconds and 60 MB.

### Support

Questions, a missing field or a feature request: contact.punkrecordsdata@gmail.com.

> **Disclaimer:** this actor is an independent tool and is not affiliated with nettivene.com, Nettix or Alma Media. It collects only publicly available data.

# Actor input Schema

## `mode` (type: `string`):

search = boat listings for the filters below (one row per ad). urls = ad, dealer-inventory, saved-search or newest-ads addresses (or ad numbers) you provide, always with full detail. dealers = the boat-dealer directory (one row per company).

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

Stops after this many rows (all record types together). Free plans are limited to 10 items per run.

## `boatTypes` (type: `array`):

Which kinds of boat to read. Empty means motor boats. Pick "All boat types" to search the whole site (sailboats, jet skis, engines, rowing boats, kayaks and the rest). Each type is searched on its own, one after another.

## `listingStatus` (type: `string`):

for-sale = ads that are live now. sold = ads the seller marked as sold (kept in the site archive; the asking price is no longer shown, so sold rows have no price).

## `makes` (type: `array`):

Optional. One or more boat makes as nettivene.com writes them, for example Buster, Yamarin, Finnmaster, Bavaria, Sea-Doo. Common short names such as HR for Hallberg-Rassy are understood; an unknown name returns close matches. Empty means every make. For engine ads this is the engine make. Several makes cannot be combined with models.

## `models` (type: `array`):

Optional. Models of the single make above, for example 4902 CLX. Needs exactly one make. Empty means every model of the make.

## `regions` (type: `array`):

Optional. Regions (maakunta) of Finland to search in. Empty means all of Finland. In dealer mode it narrows the dealer directory.

## `towns` (type: `array`):

Optional. Towns inside the single region chosen above, for example Espoo or Helsinki. Needs exactly one region in search mode.

## `minYear` (type: `integer`):

Optional. Oldest model year. 0 means no limit.

## `maxYear` (type: `integer`):

Optional. Newest model year. 0 means no limit.

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

Optional. Lowest asking price in euros. 0 means no limit.

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

Optional. Highest asking price in euros. 0 means no limit.

## `minLength` (type: `number`):

Optional. Shortest boat length in metres, for example 4.5. 0 means no limit.

## `maxLength` (type: `number`):

Optional. Longest boat length in metres, for example 9. 0 means no limit.

## `minWidth` (type: `number`):

Optional. Narrowest beam in metres, for example 2. 0 means no limit.

## `maxWidth` (type: `number`):

Optional. Widest beam in metres, for example 3. 0 means no limit.

## `minWeight` (type: `integer`):

Optional. Lightest boat in kilograms. 0 means no limit.

## `maxWeight` (type: `integer`):

Optional. Heaviest boat in kilograms. 0 means no limit.

## `minDraft` (type: `number`):

Optional. Shallowest draft in metres, for example 0.3. 0 means no limit.

## `maxDraft` (type: `number`):

Optional. Deepest draft in metres, for example 1.5. 0 means no limit.

## `minBerths` (type: `integer`):

Optional. Fewest sleeping places. 0 means no limit.

## `maxBerths` (type: `integer`):

Optional. Most sleeping places. 0 means no limit.

## `hullMaterials` (type: `array`):

Optional. Keep only these hull materials. Empty means any.

## `subTypes` (type: `array`):

Optional. Keep only these styles (the site calls it "Laji": cruiser, day cruiser, cabin boat, open console and so on). Each style exists for a few boat types only. Empty means any.

## `engineMakes` (type: `array`):

Optional. Engine makes as nettivene.com writes them, for example Yamaha, Mercury, Suzuki, Volvo Penta, Yanmar. An unknown name returns close matches. Empty means any.

## `engineTypes` (type: `array`):

Optional. Where the engine sits: outboard, inboard, stern drive, electric motor or water jet. Empty means any.

## `fuelTypes` (type: `array`):

Optional. Keep only these fuels. Empty means any.

## `engineStrokes` (type: `array`):

Optional. Two-stroke or four-stroke engines. Empty means any.

## `minEnginePower` (type: `integer`):

Optional. Lowest engine power in horsepower. 0 means no limit.

## `maxEnginePower` (type: `integer`):

Optional. Highest engine power in horsepower. 0 means no limit.

## `minEngineHours` (type: `integer`):

Optional. Lowest engine-hour reading. 0 means no limit.

## `maxEngineHours` (type: `integer`):

Optional. Highest engine-hour reading. 0 means no limit.

## `minEngineYear` (type: `integer`):

Optional. Oldest engine model year. 0 means no limit.

## `maxEngineYear` (type: `integer`):

Optional. Newest engine model year. 0 means no limit.

## `withoutEngine` (type: `boolean`):

On: only boats advertised without an engine (hull and trailer packages). Cannot be combined with engine filters.

## `accessories` (type: `array`):

Optional. Keep only boats whose ad lists all of these items (autopilot, GPS, trailer, VHF and so on). The ad page is checked, so leave "Read ad pages" on. Empty means any.

## `sellerType` (type: `string`):

Optional. dealer = boat dealers only. private = private persons only (flagged with isPrivateSeller, never named, no contact details). any means both.

## `onlyWithPrice` (type: `boolean`):

On: leave out ads that state no asking price ("price on request").

## `maxAgeDays` (type: `string`):

Optional. Keep only ads created or changed within this many days.

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

Order of the results. Newest first is the default and the best choice for monitoring.

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

Ad addresses (https://www.nettivene.com/moottorivene/buster/1234567), dealer pages (https://www.nettivene.com/yritys/1234), saved-search results (https://www.nettivene.com/hakutulokset?haku=...) or the newest ads (https://www.nettivene.com/uusimmat).

## `listingIds` (type: `array`):

Ad numbers (the number at the end of an ad address), for example 1055080.

## `dealerIds` (type: `array`):

Dealer numbers (the number in a dealer page address, https://www.nettivene.com/yritys/1234). Empty means walk the directory with the regions and towns above.

## `dealerQuery` (type: `string`):

Optional. Keep only dealers whose name contains these words, for example "Marine".

## `fetchDetails` (type: `boolean`):

On (default): every ad page is read for the full record (description, equipment, size, engine block, seller, update date, dealer address) and billed as a detail record. Off: only the list card is read (title, price, year, engine line, city, photos), billed as a standard record. For dealers: on adds the profile (website, logo, description, address).

## `includeContactDetails` (type: `boolean`):

Off (default): phone numbers and e-mail addresses written into dealer texts are replaced by a marker and no phone is read. On: dealer texts are kept as written, ad rows of dealers get sellerPhone and dealer rows get phone, the business line behind the call button (one extra request each). Named sales people and private persons never get contact data, whatever this says.

## `includeRaw` (type: `boolean`):

Adds a "raw" column with the unprocessed data blocks of the site (list card and ad page analytics data).

## `onlyNew` (type: `boolean`):

Schedule the Actor and receive only ads you have not been given before. The first run returns everything and builds the memory. Use together with sort "Newest first".

## `stateKey` (type: `string`):

Optional name of the monitor memory. Same label plus same filters = same memory. Empty derives the label from the filters.

## `resetSeen` (type: `boolean`):

Forget everything seen before and start the memory again. Use after changing what you want to track.

## `maxConcurrency` (type: `integer`):

Ad pages read at the same time. The site answers slowly; 2 is the polite default.

## `maxScanSeconds` (type: `integer`):

Stops reading after this many seconds and delivers what was collected.

## Actor input object example

```json
{
  "mode": "search",
  "maxItems": 3,
  "boatTypes": [
    "motor-boat"
  ],
  "listingStatus": "for-sale",
  "makes": [],
  "models": [],
  "regions": [],
  "towns": [],
  "hullMaterials": [],
  "subTypes": [],
  "engineMakes": [],
  "engineTypes": [],
  "fuelTypes": [],
  "engineStrokes": [],
  "withoutEngine": false,
  "accessories": [],
  "sellerType": "any",
  "onlyWithPrice": false,
  "maxAgeDays": "any",
  "sortBy": "newest",
  "startUrls": [],
  "listingIds": [],
  "dealerIds": [],
  "dealerQuery": "",
  "fetchDetails": true,
  "includeContactDetails": false,
  "includeRaw": false,
  "onlyNew": false,
  "stateKey": "",
  "resetSeen": false,
  "maxConcurrency": 2,
  "maxScanSeconds": 3000
}
```

# Actor output Schema

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

Key fields per row

## `fullData` (type: `string`):

Complete dataset with all fields

# 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 = {
    "maxItems": 3,
    "boatTypes": [
        "motor-boat"
    ],
    "makes": [],
    "models": [],
    "regions": [],
    "towns": [],
    "minYear": 0,
    "maxYear": 0,
    "minPrice": 0,
    "maxPrice": 0,
    "minLength": 0,
    "maxLength": 0,
    "minWidth": 0,
    "maxWidth": 0,
    "minWeight": 0,
    "maxWeight": 0,
    "minDraft": 0,
    "maxDraft": 0,
    "minBerths": 0,
    "maxBerths": 0,
    "hullMaterials": [],
    "subTypes": [],
    "engineMakes": [],
    "engineTypes": [],
    "fuelTypes": [],
    "engineStrokes": [],
    "minEnginePower": 0,
    "maxEnginePower": 0,
    "minEngineHours": 0,
    "maxEngineHours": 0,
    "minEngineYear": 0,
    "maxEngineYear": 0,
    "accessories": [],
    "startUrls": [],
    "listingIds": [],
    "dealerIds": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("recordsdata/nettivene-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 = {
    "maxItems": 3,
    "boatTypes": ["motor-boat"],
    "makes": [],
    "models": [],
    "regions": [],
    "towns": [],
    "minYear": 0,
    "maxYear": 0,
    "minPrice": 0,
    "maxPrice": 0,
    "minLength": 0,
    "maxLength": 0,
    "minWidth": 0,
    "maxWidth": 0,
    "minWeight": 0,
    "maxWeight": 0,
    "minDraft": 0,
    "maxDraft": 0,
    "minBerths": 0,
    "maxBerths": 0,
    "hullMaterials": [],
    "subTypes": [],
    "engineMakes": [],
    "engineTypes": [],
    "fuelTypes": [],
    "engineStrokes": [],
    "minEnginePower": 0,
    "maxEnginePower": 0,
    "minEngineHours": 0,
    "maxEngineHours": 0,
    "minEngineYear": 0,
    "maxEngineYear": 0,
    "accessories": [],
    "startUrls": [],
    "listingIds": [],
    "dealerIds": [],
}

# Run the Actor and wait for it to finish
run = client.actor("recordsdata/nettivene-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 '{
  "maxItems": 3,
  "boatTypes": [
    "motor-boat"
  ],
  "makes": [],
  "models": [],
  "regions": [],
  "towns": [],
  "minYear": 0,
  "maxYear": 0,
  "minPrice": 0,
  "maxPrice": 0,
  "minLength": 0,
  "maxLength": 0,
  "minWidth": 0,
  "maxWidth": 0,
  "minWeight": 0,
  "maxWeight": 0,
  "minDraft": 0,
  "maxDraft": 0,
  "minBerths": 0,
  "maxBerths": 0,
  "hullMaterials": [],
  "subTypes": [],
  "engineMakes": [],
  "engineTypes": [],
  "fuelTypes": [],
  "engineStrokes": [],
  "minEnginePower": 0,
  "maxEnginePower": 0,
  "minEngineHours": 0,
  "maxEngineHours": 0,
  "minEngineYear": 0,
  "maxEngineYear": 0,
  "accessories": [],
  "startUrls": [],
  "listingIds": [],
  "dealerIds": []
}' |
apify call recordsdata/nettivene-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,recordsdata/nettivene-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/kpJnZJaBLKPVwkfu8/builds/cwEWMZ3OzL2O42oKE/openapi.json