# Nettimoto Scraper: Motorcycle Listings Finland (`recordsdata/nettimoto-scraper`) Actor

Scrape nettimoto.com, Finland's largest motorcycle marketplace: motorcycles, scooters, mopeds, ATVs and snowmobiles with EUR prices, make, model, year, mileage or hours, engine size, photos and dealers, plus the dealer directory and sold archive. No login, no proxy. Export JSON, CSV or Excel.

- **URL**: https://apify.com/recordsdata/nettimoto-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 vehicle listings

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)

## Nettimoto Scraper: Motorcycle, Scooter, ATV and Snowmobile Listings from nettimoto.com (Finland)

> Nettimoto Scraper is an Apify Actor that extracts motorcycle, scooter, moped, ATV, snowmobile and other vehicle listings from nettimoto.com, the Finnish motorcycle marketplace, with EUR prices, make, model, year, mileage or engine hours, engine size, equipment, photos and dealer details. On 2026-10-23 the site listed 22,927 vehicles for sale, 9,451 of them motorcycles. Export JSON, CSV, Excel, XML or HTML, with no login and no proxy. Pricing is pay per event.

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

### What can you scrape from Nettimoto?

- **Vehicle listings**: 22,927 vehicles for sale on 2026-10-23 across 15 vehicle types, newest first. Motorcycles are the default (9,451 ads); scooters, mopeds, ATVs, snowmobiles, electric vehicles, trikes, karting cars and the other types are one setting away.
- **Ad details** (on by default): the seller's text and one-line selling point, equipment list, colour and finish, first registration, number of owners, warranty, last update date, the full photo gallery, video link, office fee and the dealer's street address and website.
- **Sold archive**: 39,236 sold motorcycle ads and 83,440 sold ads in all types on 2026-10-23, with the vehicle data the ad kept.
- **Dealers**: the directory of 326 motorcycle dealers in 19 regions, with address, number of ads, website, logo and description.

### Why use this actor?

- **Real filters, applied by the site**: 40 input fields, from make, model, region and town to price, year, mileage, engine hours, engine size, power class, drive, colour, body style, seller type and 9 sort orders.
- **Whole catalogue reachable**: no depth cap was found.
- **Light to run**: plain HTTP, no browser, no proxy. 13 of 13 cloud runs of 3 results passed, median 7.1 seconds, peak memory 41 to 67 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 nettimoto.com in four steps

1. Open the actor in Apify Console and choose **What to collect**.
2. Add makes such as `Honda` or `Yamaha` and the filters you need, or leave everything empty for the newest motorcycles.
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 vehicles by 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`, `dealer` |
| `dealers` | List the dealer directory by region, town or name, or read dealers by number | `dealer` |

### Input

The form has 40 fields. The main ones:

| Field | Type | Default | Meaning |
|---|---|---|---|
| `mode` | string | `search` | `search`, `urls` or `dealers` |
| `maxItems` | integer | 50 | Maximum rows (free plans: 10) |
| `vehicleTypes`, `listingStatus` | array, string | `["motorcycle"]`, `for-sale` | 15 vehicle types or `all`; `for-sale` or `sold` |
| `makes`, `models` | array | empty | Names as the site writes them, for example `Honda`, `CBR` |
| `regions`, `towns` | array | empty | The 19 regions of Finland plus Outside Finland, and towns |
| `bodyTypes`, `driveTypes`, `colors` | array | empty | 22 body styles, chain, belt or shaft drive, 15 colours |
| `engineType`, `transmission`, `powerClass` | string | `any` | 2-stroke, 4-stroke, diesel, electric; gearbox; up to 11, 35 or 70 kW |
| `minPrice`, `maxPrice`, `onlyWithPrice` | integer, boolean | none | Price range in EUR |
| `minYear`, `maxYear`, `minMileage`, `maxMileage`, `minHours`, `maxHours` | integer | none | Year, odometer (km) and engine hour ranges |
| `minEngineSize`, `maxEngineSize` | integer | none | Engine size in cm3 |
| `sellerType`, `roadWorthy`, `maxAgeDays` | string | `any` | Dealer or private; yes or no; updated within 1, 3, 7, 14 or 28 days |
| `sortBy` | string | `newest` | 9 orders: newest, oldest, price, year, mileage, make and model |
| `startUrls`, `listingIds`, `dealerIds`, `dealerQuery` | array, string | empty | Ad and dealer addresses or numbers; dealer name search |
| `fetchDetails`, `includeContactDetails`, `includeRaw` | boolean | `true`, `false`, `false` | Read every ad page; dealer business phone; source objects |
| `onlyNew`, `stateKey`, `resetSeen` | boolean, string | `false` | Monitor mode controls |
| `maxConcurrency`, `maxScanSeconds` | integer | 2, 3000 | Request concurrency and scan time limit |

A minimal example:

```json
{
  "mode": "search",
  "makes": ["Honda"],
  "models": ["CBR"],
  "minYear": 2015,
  "maxPrice": 12000,
  "sortBy": "price-asc",
  "maxItems": 100
}
```

### What data do you get?

Every row has a `recordType`: `vehicle` or `dealer`. There are 56 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` | `nettimoto.com`, `FI`, `sale`, `for-sale` or `sold`, and `motorcycle`, `scooter`, `moped`, `atv`, `snowmobile` and the other types |
| `title`, `headline`, `description` | Ad title, the seller's one-line selling point and the seller's text |
| `price`, `currency`, `vatDeductible`, `priceWithOfficeFee`, `officeFee`, `priceChange` | Advertised price in EUR, VAT deductible flag, price with the dealer's office fee, `reduced` when the site shows a drop |
| `make`, `model`, `trim`, `year`, `firstRegistration` | Identity and age of the vehicle |
| `mileage`, `mileageUnit`, `roadWorthy`, `owners`, `warranty` | Odometer in km or engine hours, roadworthiness, number of owners, warranty text |
| `engineType`, `engineSize`, `transmission`, `bodyType`, `driveType` | 2-stroke, 4-stroke, diesel or electric; engine size in cm3; gearbox, body style and drive as lowercase enums |
| `color`, `colorFinish` | Colour and finish such as metallic |
| `features` | Equipment list |
| `city`, `region`, `address` | Place of the vehicle; 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 |

#### Sample output

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

```json
{
  "recordType": "vehicle",
  "listingId": "3246241",
  "url": "https://www.nettimoto.com/honda/cbr/3246241",
  "listingStatus": "for-sale",
  "vehicleType": "motorcycle",
  "title": "Honda CBR",
  "price": 33999,
  "currency": "EUR",
  "priceWithOfficeFee": 34149,
  "officeFee": 150,
  "make": "Honda",
  "model": "CBR",
  "trim": "1000 RR-R Fireblade SP UUSI KORINEN RR-R!",
  "year": 2024,
  "firstRegistration": "2024-06",
  "mileage": 6300,
  "mileageUnit": "km",
  "engineType": "4-stroke",
  "engineSize": 1000,
  "transmission": "manual",
  "bodyType": "street-touring-sport",
  "driveType": "chain",
  "color": "red",
  "colorFinish": "metallic",
  "owners": 1,
  "city": "Vantaa",
  "region": "Uusimaa",
  "imageCount": 12,
  "updatedAt": "2026-09-16",
  "sellerName": "Bike World, Vantaa",
  "isPrivateSeller": false,
  "scrapedAt": "2026-10-23T22:02:22.943Z"
}
```

### How much does the Nettimoto Scraper cost?

Pay per event, no monthly fee. Three events exist, with these rates in USD on the Free tier:

| Event | Charged for | Price per result | Per 1,000 |
|---|---|---|---|
| `vehicle-record` | One vehicle taken from the search list, no ad page read | $0.022 | $22.00 |
| `vehicle-detail-record` (default) | One vehicle with its own ad page read | $0.03373 | $33.73 |
| `dealer-record` | One dealer from the directory | $0.03373 | $33.73 |

Your total for 1,000 results is 1,000 times the rate of the event you use: 1,000 list-only vehicles cost $22.00, and 1,000 vehicles with ad pages or 1,000 dealers cost $33.73. With **Read ad pages** off, rows count as `vehicle-record`. Error rows, empty searches and ads skipped by monitoring are charged $0.

### 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 (`nettimoto-seen`). A scheduled run with the same filters returns only unseen ads and reads the newest-first list only until it meets known ones.

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

The Apify Store has no other actor for nettimoto.com. The nearest motorcycle actor is `piotrv1001/cycletrader-listings-scraper`, which serves the United States (1,358 runs and 3 users in 30 days). The five Nettiauto actors cover the sister car site and no motorcycles.

| | Nettimoto Scraper | CycleTrader listings scraper |
|---|---|---|
| Site and country | nettimoto.com, Finland, EUR | cycletrader.com, United States |
| Published fields | 56 | 38 |
| Fields in common | 23 | 23 |
| Extra fields here | office fee apart from price, engine size, engine type, first registration, equipment, colour and finish, warranty, owners, video, dealer address, sold archive | none |
| Fields only there | condition, MSRP, class, category, hours, serial and stock number, zip, latitude, longitude, premium and trusted-partner flags | n/a |

Nettimoto Scraper outputs no map coordinates, because the ad and dealer pages carry none, and no registration plates. It adds the dealer directory, monitoring and the privacy rules. For United States listings use the rival, 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/nettimoto-scraper`.

Example prompt: "List the 20 cheapest Yamaha motorcycles from 2018 or newer in Uusimaa with price, mileage and dealer."

### Is it legal to scrape nettimoto.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. Two things are on record and you should weigh both before you collect data.

- **robots.txt**: for all robots it disallows only `/build/`, `/bundles/` and `/ad-detail/print/`, 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 plates are not output.

Limits:

- A filter on something that few ads state leaves out the ads that do not state it. For example only 1 of 1,254 scooter ads states a transmission, so a transmission filter on scooters returns almost nothing.
- List-card mileage is rounded to thousands; keep **Read ad pages** on for the exact number.
- Sold ads carry no price and a placeholder photo.

### Frequently Asked Questions

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

Open the actor, pick `search`, 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 nettimoto.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 vehicle read from the search list only is one event, a vehicle with its ad page (the default) is a second, higher event, and a dealer is a third. Rates are $0.022, $0.03373 and $0.03373 per result. Error rows, empty searches and ads skipped by monitoring are never charged.

#### Which vehicles does it cover?

Motorcycles by default, and with **Vehicle types** also mopeds, scooters, ATVs, snowmobiles, electric vehicles, trikes, quads, karting cars, minimotos and the other types of the site. 22,927 vehicles were for sale on 2026-10-23, 9,451 of them motorcycles. 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. Set `maxItems` to what you need. A scan stops after `maxScanSeconds`; split very large reads by make, region or year, and use monitor mode for follow-ups.

#### 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 year 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 letters intact. Technical values such as engine type, gearbox and drive 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. It does not use a browser either, which keeps a 3-result run near 7 seconds and 60 MB. Only if the site ever shows a bot challenge does the actor switch to a browser-like TLS client by itself.

### 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 nettimoto.com, Nettix or Alma Media. It collects only publicly available data.

Last updated: 2026-10-24

# Actor input Schema

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

search = vehicle 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 motorcycle-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.

## `vehicleTypes` (type: `array`):

Which kinds of vehicle to read. Empty means motorcycles. Pick "All vehicle types" to search the whole site (snowmobiles, ATVs, scooters, mopeds and the rest).

## `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 makes as nettimoto.com writes them, for example Honda, Yamaha, Harley-Davidson, Ski-Doo. Common short names such as HD or Guzzi are understood; an unknown name returns close matches. Empty means every make. Several makes cannot be combined with models.

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

Optional. Models of the single make above, for example CBR or MT. 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.

## `bodyTypes` (type: `array`):

Optional. Keep only these styles (the site calls it the vehicle type: cruiser, enduro, touring, snowmobile touring and so on). Each style belongs to one vehicle type, which must be among the vehicle types above. Empty means any.

## `engineType` (type: `string`):

Optional. Two-stroke, four-stroke, diesel or electric engine. any means all.

## `transmission` (type: `string`):

Optional. Gearbox type. any means all.

## `driveTypes` (type: `array`):

Optional. Keep only these drive layouts (chain, belt, shaft, front, rear, four-wheel, six-wheel). Empty means any.

## `colors` (type: `array`):

Optional. Keep only these colors. Empty means any.

## `powerClass` (type: `string`):

Optional. The power classes of the site (kW): up to 11, up to 35, up to 70, or its other class. Each class includes the smaller ones. Only ads that state a class are matched. The site prints no power on its ads, so this narrows the search but adds no column. any means all.

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

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

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

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

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

On: skip ads that carry no price ("Ei hinnoiteltu", about 1 in 6 motorcycle ads). Off (default): keep them, price left empty.

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

Optional. Oldest model year. 0 means no limit.

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

Optional. Newest model year. 0 means no limit.

## `minMileage` (type: `integer`):

Optional. Lowest odometer reading in kilometres. Ads that count engine hours instead are not matched. 0 means no limit.

## `maxMileage` (type: `integer`):

Optional. Highest odometer reading in kilometres. Ads that count engine hours instead are not matched. 0 means no limit.

## `minHours` (type: `integer`):

Optional. Lowest engine-hour reading (ATVs, snowmobiles, crosskarts and some motorcycles count hours instead of kilometres). 0 means no limit.

## `maxHours` (type: `integer`):

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

## `minEngineSize` (type: `integer`):

Optional. Smallest engine displacement in cubic centimetres, for example 125. 0 means no limit.

## `maxEngineSize` (type: `integer`):

Optional. Largest engine displacement in cubic centimetres, for example 650. 0 means no limit.

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

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

## `roadWorthy` (type: `string`):

Optional. yes = vehicles the seller lists as roadworthy. no = vehicles the seller marks as not roadworthy (project bikes, off-road and race machines). The site prints only the negative on its ads, so a roadWorthy column appears only on "not roadworthy" ads. any means both.

## `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.nettimoto.com/honda/cbr/12345678), dealer pages (https://www.nettimoto.com/yritys/1234), saved-search results (https://www.nettimoto.com/hakutulokset?haku=...) or the newest ads (https://www.nettimoto.com/uusimmat).

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

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

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

Dealer numbers (the number in a dealer page address, https://www.nettimoto.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 "Moto".

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

On (default): every ad page is read for the full record (description, equipment, seller, update date, dealer address) and billed as a detail record. Off: only the list card is read (title, price, year, mileage, engine, drive, 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,
  "vehicleTypes": [
    "motorcycle"
  ],
  "listingStatus": "for-sale",
  "makes": [],
  "models": [],
  "regions": [],
  "towns": [],
  "bodyTypes": [],
  "engineType": "any",
  "transmission": "any",
  "driveTypes": [],
  "colors": [],
  "powerClass": "any",
  "onlyWithPrice": false,
  "sellerType": "any",
  "roadWorthy": "any",
  "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,
    "vehicleTypes": [
        "motorcycle"
    ],
    "makes": [],
    "models": [],
    "regions": [],
    "towns": [],
    "bodyTypes": [],
    "driveTypes": [],
    "colors": [],
    "minPrice": 0,
    "maxPrice": 0,
    "minYear": 0,
    "maxYear": 0,
    "minMileage": 0,
    "maxMileage": 0,
    "minHours": 0,
    "maxHours": 0,
    "minEngineSize": 0,
    "maxEngineSize": 0,
    "startUrls": [],
    "listingIds": [],
    "dealerIds": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("recordsdata/nettimoto-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,
    "vehicleTypes": ["motorcycle"],
    "makes": [],
    "models": [],
    "regions": [],
    "towns": [],
    "bodyTypes": [],
    "driveTypes": [],
    "colors": [],
    "minPrice": 0,
    "maxPrice": 0,
    "minYear": 0,
    "maxYear": 0,
    "minMileage": 0,
    "maxMileage": 0,
    "minHours": 0,
    "maxHours": 0,
    "minEngineSize": 0,
    "maxEngineSize": 0,
    "startUrls": [],
    "listingIds": [],
    "dealerIds": [],
}

# Run the Actor and wait for it to finish
run = client.actor("recordsdata/nettimoto-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,
  "vehicleTypes": [
    "motorcycle"
  ],
  "makes": [],
  "models": [],
  "regions": [],
  "towns": [],
  "bodyTypes": [],
  "driveTypes": [],
  "colors": [],
  "minPrice": 0,
  "maxPrice": 0,
  "minYear": 0,
  "maxYear": 0,
  "minMileage": 0,
  "maxMileage": 0,
  "minHours": 0,
  "maxHours": 0,
  "minEngineSize": 0,
  "maxEngineSize": 0,
  "startUrls": [],
  "listingIds": [],
  "dealerIds": []
}' |
apify call recordsdata/nettimoto-scraper --silent --output-dataset

```

## MCP server setup

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