# Nettiauto Scraper - Finnish Car Marketplace Data (`studio-amba/nettiauto-scraper`) Actor

Scrape car listings from Nettiauto.com, Finland's largest dedicated car marketplace. Extract prices, specs, mileage, fuel type, location. No login required.

- **URL**: https://apify.com/studio-amba/nettiauto-scraper.md
- **Developed by:** [Studio Amba](https://apify.com/studio-amba) (community)
- **Categories:** E-commerce
- **Stats:** 7 total users, 3 monthly users, 64.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.20 / 1,000 result scrapeds

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?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Nettiauto Scraper - Finnish Car Marketplace Data

Scrape car listings from [Nettiauto.com](https://www.nettiauto.com), Finland's largest dedicated car marketplace. Extract structured vehicle data including prices, specifications, mileage, fuel type, transmission, engine power, and seller information. No login or cookies required.

Nettiauto.com is Finland's premier car sales platform with over 50,000 active listings at any time, covering both private sellers and professional dealers across the country. Unlike general classifieds sites, Nettiauto is purpose-built for vehicle sales and provides highly structured listing data with detailed technical specifications.

### Why use this scraper?

- **Structured car data** -- Get make, model, year, price, mileage, fuel type, transmission, engine power, and location in a clean JSON or CSV format.
- **No login required** -- Works without authentication, cookies, or account creation.
- **Finland's #1 car marketplace** -- Access the largest dedicated car sales platform in Finland with 50,000+ active listings.
- **Flexible filtering** -- Search by keyword, specific make/model, year range, price range, and fuel type.
- **Automatic pagination** -- Crawls through all search result pages up to your specified limit.
- **Anti-detection built in** -- Uses Finnish proxy IPs, proper Accept-Language headers, and session rotation to avoid blocks.
- **Export to any format** -- Download results as JSON, CSV, XML, or Excel. Push to Google Sheets, webhooks, or other integrations via the Apify platform.

### How to scrape Nettiauto data

1. **Create an Apify account** -- Sign up at [Apify](https://apify.com) if you do not already have an account. New accounts get free monthly credits.

2. **Open the Nettiauto Scraper** -- Navigate to the actor page and click "Start" or "Try for free."

3. **Configure your search** -- Enter a search query (e.g., "volkswagen golf") or specify the make and model fields separately for more precise results. Optionally set year range, price range, and fuel type filters.

4. **Set the result limit** -- Adjust "Max Results" to control how many listings you want. The default is 100. Lower values reduce runtime and cost.

5. **Run the scraper** -- Click "Start" and wait for the run to complete. Progress is shown in the log output.

6. **Download your data** -- Once finished, go to the "Dataset" tab to preview results. Export as JSON, CSV, XML, or Excel. You can also connect the output to Google Sheets, webhooks, Slack, or any Apify integration.

### Input parameters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `searchQuery` | string | `volkswagen` | Free-text search term. Used when Make is not specified. |
| `make` | string | | Car manufacturer (e.g., `volkswagen`, `toyota`, `bmw`). Uses Nettiauto's make-based URL path for better results. |
| `model` | string | | Car model (e.g., `golf`, `corolla`). Only works when Make is also provided. |
| `yearFrom` | integer | | Minimum registration year (e.g., 2015). |
| `yearTo` | integer | | Maximum registration year (e.g., 2024). |
| `priceFrom` | integer | | Minimum listing price in EUR. |
| `priceTo` | integer | | Maximum listing price in EUR. |
| `fuelType` | string | | Filter by fuel type: Bensiini (gasoline), Diesel, Sahko (electric), Hybridi, Kaasu (gas). |
| `maxResults` | integer | `100` | Maximum number of listings to scrape (1 -- 10,000). |
| `proxyConfiguration` | object | Residential FI | Proxy settings. Finnish residential proxies are recommended. |

### Output example

Each scraped listing produces a JSON object like this:

```json
{
    "listingTitle": "Volkswagen Golf Variant 1,0 eTSI MHEV 81 kW DSG-automaatti",
    "make": "Volkswagen",
    "model": "Golf",
    "year": 2022,
    "price": 24900,
    "currency": "EUR",
    "mileage": 45000,
    "fuelType": "Bensiini",
    "transmission": "Automaatti",
    "engineSize": "1.0 l",
    "power": "81 kW",
    "location": "Helsinki",
    "sellerType": "dealer",
    "imageUrl": "https://img.nettiauto.com/volkswagen/golf/large/12345.jpg",
    "url": "https://www.nettiauto.com/volkswagen/golf/15666255",
    "scrapedAt": "2026-06-09T12:00:00.000Z"
}
```

### Data fields

| Field | Type | Description |
|-------|------|-------------|
| `listingTitle` | string | Full listing title as shown on Nettiauto.com |
| `make` | string | Car manufacturer (Volkswagen, Toyota, BMW, etc.) |
| `model` | string | Car model name (Golf, Corolla, 3 Series, etc.) |
| `year` | integer | Registration year |
| `price` | number | Listing price in EUR |
| `currency` | string | Always `EUR` (Finland uses the Euro) |
| `mileage` | integer | Odometer reading in kilometers |
| `fuelType` | string | Fuel type in Finnish (Bensiini, Diesel, Sahko, Hybridi, Kaasu) |
| `transmission` | string | Transmission type (Automaatti = automatic, Manuaali = manual) |
| `engineSize` | string | Engine displacement when available (e.g., 2.0 l) |
| `power` | string | Engine power in kW or hv (e.g., 135 kW, 184 hv) |
| `location` | string | Seller location in Finland |
| `sellerType` | string | `private` or `dealer` |
| `imageUrl` | string | URL of the main listing image |
| `url` | string | Direct link to the listing on Nettiauto.com |
| `scrapedAt` | string | ISO 8601 timestamp when data was collected |

### Cost estimate

This actor charges $0.02 per run (start fee, based on its 4 GB memory allocation) plus $0.002 per result. 50 listings costs about $0.12; 500 about $1.02; 5,000 about $10.02. Residential proxy cost is absorbed into that per-result price, not billed separately. A run's usage cost only settles after it reports SUCCEEDED.

### Tips

- **Use Make + Model for precise results.** Setting the `make` field (and optionally `model`) uses Nettiauto's structured URL paths (e.g., `/volkswagen/golf`), which return cleaner and more relevant results than free-text search.
- **Start with a small maxResults.** Test with 10--20 results first to verify the output matches your expectations before running larger scrapes.
- **Finnish fuel types.** Nettiauto uses Finnish terms: Bensiini = gasoline, Sahko = electric, Hybridi = hybrid, Kaasu = natural gas.
- **Finnish proxy IPs are recommended.** Nettiauto.com may show different content or block non-Finnish IPs. The default configuration uses Finnish residential proxies.
- **Combine with other scrapers.** For pan-Nordic or European car market analysis, combine this data with our Tori.fi, Finn.no, Blocket, AutoScout24, and other car classifieds scrapers.

### Frequently asked questions

**Can I scrape all car listings from Nettiauto?**
Yes. Set `maxResults` to a high number (e.g., 10000) and leave the search query broad. The scraper will paginate through all available results.

**Does this scraper require a Nettiauto account?**
No. All data is scraped from publicly available search results. No login, cookies, or account is needed.

**What is the difference between Nettiauto and Tori.fi?**
Nettiauto.com is Finland's dedicated car marketplace, purpose-built for vehicle sales with detailed technical specs. Tori.fi is a general classifieds platform (like Craigslist) that also has a cars section. Nettiauto typically has more detailed vehicle data and more dealer listings.

**What proxy should I use?**
Finnish residential proxies give the best results. The default proxy configuration is already set to use Apify's residential proxy pool with a Finnish IP.

**Can I filter by city or region?**
Location filtering is available through the search query. For example, search for "volkswagen helsinki" to find Volkswagen listings in Helsinki.

**How often can I run this scraper?**
As often as you need. Set up a scheduled run (daily, weekly) to track price changes and new listings over time.

**What if the scraper returns zero results?**
The scraper will report a failure if zero results are found. Check that your search query matches actual listings on Nettiauto.com, and verify your proxy settings are working.

### About Nettiauto.com

[Nettiauto.com](https://www.nettiauto.com) is Finland's largest dedicated car marketplace, part of the Nettix group (which also operates Nettimoto for motorcycles and Nettikaravaani for caravans). The platform has been the go-to destination for car buyers and sellers in Finland since the early 2000s.

Nettiauto hosts over 50,000 active vehicle listings at any time, from both private sellers and hundreds of professional car dealers across Finland. Listings include detailed technical specifications such as engine size, power output, transmission type, fuel consumption, and inspection history.

Finland's used car market operates in EUR, with popular brands including Toyota, Volkswagen, Volvo, BMW, Mercedes-Benz, Skoda, Ford, and Hyundai. The platform supports both Finnish and English interfaces.

# Actor input Schema

## `searchQuery` (type: `string`):

Free-text search term (e.g. 'volkswagen golf', 'toyota corolla'). Used when Make is not specified.

## `make` (type: `string`):

Car manufacturer (e.g. 'volkswagen', 'toyota', 'bmw'). Uses Nettiauto's make-based URL for better results.

## `model` (type: `string`):

Car model (e.g. 'golf', 'corolla', '3-series'). Only works when Make is also specified.

## `yearFrom` (type: `integer`):

Minimum registration year (e.g. 2015).

## `yearTo` (type: `integer`):

Maximum registration year (e.g. 2024).

## `priceFrom` (type: `integer`):

Minimum listing price in euros.

## `priceTo` (type: `integer`):

Maximum listing price in euros.

## `fuelType` (type: `string`):

Filter by fuel type.

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

Maximum number of car listings to scrape.

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

Proxy settings. Residential proxies with Finnish IP are recommended for reliable results.

## Actor input object example

```json
{
  "searchQuery": "volkswagen",
  "fuelType": "",
  "maxResults": 5,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "FI"
  }
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# 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 = {
    "searchQuery": "volkswagen",
    "maxResults": 5,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "FI"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("studio-amba/nettiauto-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 = {
    "searchQuery": "volkswagen",
    "maxResults": 5,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "FI",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("studio-amba/nettiauto-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 '{
  "searchQuery": "volkswagen",
  "maxResults": 5,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "FI"
  }
}' |
apify call studio-amba/nettiauto-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,studio-amba/nettiauto-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/rNo0Ivd3FcI0W3klX/builds/L3HdvgXma7QIV3IGp/openapi.json