# Finn.no Scraper — Norway Used Car Listings & Prices (`rastriq/finn-no-scraper`) Actor

Scrape used and new car listings from Finn.no, Norway's largest marketplace. Get make, model, year, mileage, price in NOK, fuel, gearbox, city, dealer or private seller, photo and URL. No proxy needed.

- **URL**: https://apify.com/rastriq/finn-no-scraper.md
- **Developed by:** [Rastriq — Structured data from the world](https://apify.com/rastriq) (community)
- **Categories:** E-commerce, Lead generation, Automation
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## 🚗 Finn.no Scraper — Norway Used Car Listings & Prices

**Finn.no Scraper** extracts car listings from [finn.no](https://www.finn.no/mobility/search/car), Norway's largest online marketplace, into clean structured data. Get make, model, year, mileage, asking price in NOK, fuel type, gearbox, city, dealer or private seller, photo and listing URL for thousands of cars in a single run. Export to JSON, CSV, Excel or straight into your pipeline through the Apify API. No login and no proxy needed.

### What is Finn.no Scraper?

Finn.no is where Norway buys and sells cars: tens of thousands of used and new cars are listed for sale at any time, from private sellers and dealers alike. Finn.no has no public API for its car search, so collecting this data by hand means copying it page by page.

**Finn.no Scraper** reads Finn.no car search result pages the way your browser does and turns every listing card into one row of data. You can scrape the whole car market or narrow the search to a single make, and cap the run by pages or by number of listings so you only pay for what you need.

It is a lightweight HTTP scraper (no browser), so runs are fast and cheap: a test run returned 20 listings in about 6 seconds using under 80 MB of memory.

### 🎯 Who uses a Finn.no scraper?

- 📈 **Price monitoring:** track asking prices for a make or model in Norway week after week.
- 🏷️ **Car valuation:** feed real market listings into valuation models and price estimators.
- 🏪 **Dealers and importers:** benchmark your stock against what competitors are asking, and spot cars to buy.
- ⚡ **EV market research:** Norway is the world's most electrified car market. Measure the share of electric (`El`), hybrid and plug-in cars on offer, by make and year.
- 🧭 **Dealer vs private split:** segment supply by seller type with the `is_professional` flag.
- 🌍 **Nordic and European market intelligence:** combine Finn.no data with other Rastriq car scrapers (links below) for cross-country comparisons.

### 📋 What data does Finn.no Scraper extract?

Each listing is one dataset item with these fields:

| Field | Description |
|---|---|
| 🆔 `id` | Finn.no listing id (finnkode) |
| 🔗 `url` | Direct link to the listing |
| 🖼️ `img_url` | Main photo URL |
| 📝 `title` | Listing title, e.g. "Volvo XC60" |
| 🏭 `make` | Make, e.g. Volvo, Tesla, Land Rover |
| 🚙 `model` | Model, e.g. XC60, Model 3 |
| 📅 `year` | Model year |
| 🛣️ `km` | Mileage in kilometres |
| ⛽ `fuel_type` | Fuel as published in Norwegian: `Bensin` (petrol), `Diesel`, `El` (electric), `Hybrid bensin`, `Plug-in Bensin`… |
| ⚙️ `gearbox` | `Automat` or `Manuell`; empty when the card does not show it, which is usual for electric cars |
| 💰 `price` | Asking price in Norwegian kroner |
| 💱 `currency` | Always `NOK` |
| 📍 `city` | Location shown on the listing |
| 🏢 `is_professional` | `true` for dealers (Forhandler, Merkeforhandler), `false` for private sellers (Privat, including Finn's "Smidig bilhandel") |
| 🏷️ `source` | Always `finn_no` |
| 🕒 `scraped_at` | UTC timestamp of extraction |

The dataset also carries two reserved columns, `hp` and `region`, kept for compatibility with other Rastriq car scrapers. Finn.no search results do not show them, so they are always empty.

Finn.no Scraper only reads the public search result pages. It does not open each listing, so it does not return the full description, equipment list, VIN, registration number or seller contact details.

### 🚀 How to use Finn.no Scraper

1. Open **Finn.no Scraper** in Apify Console and click **Try for free**.
2. Optionally enter a **Make** code to search a single make (see the table below), or leave it empty to scrape all cars.
3. Set **Max search pages** (about 50 listings per page) and **Max listings**.
4. Click **Start**. A 50-listing run finishes in seconds.
5. Download the results from the **Output** tab as JSON, CSV, Excel or HTML, or fetch them with the Apify API.

To keep data fresh, save your input as a task and schedule it daily or weekly.

### ⚙️ Input parameters

| Parameter | Type | Default | Description |
|---|---|---|---|
| `make` | string | empty (all makes) | Finn.no make code, the value of the `variant` parameter in a Finn.no car search URL |
| `maxPages` | integer | 3 | Result pages to crawl, about 50 listings each. Maximum 50 |
| `maxItems` | integer | 100 | Maximum number of listings saved and charged |
| `proxyConfiguration` | object | none | Optional Apify Proxy. Not needed in our tests |

**Make codes verified on Finn.no:**

| Make | Code |
|---|---|
| BMW | `0.749` |
| Toyota | `0.813` |
| Volkswagen | `0.817` |
| Volvo | `0.818` |
| Tesla | `0.8078` |

For any other make, filter by that make on finn.no and copy the number after `variant=` from the address bar.

**Example input** — the first 50 Volvo listings:

```json
{
  "make": "0.818",
  "maxPages": 1,
  "maxItems": 50
}
```

### 📦 Output example

A real item from a Finn.no Scraper run on 14 November 2026:

```json
{
  "id": "480334002",
  "url": "https://www.finn.no/mobility/item/480334002",
  "img_url": "https://images.finncdn.no/dynamic/default/item/480334002/a580492b-395f-4df8-a558-fb9a732a3ee7",
  "title": "Volkswagen ID.4 GTX",
  "make": "Volkswagen",
  "model": "ID.4 GTX",
  "year": 2026,
  "km": 15528,
  "fuel_type": "El",
  "gearbox": "",
  "price": 549000,
  "city": "Oslo",
  "is_professional": true,
  "hp": null,
  "currency": "NOK",
  "region": "",
  "source": "finn_no",
  "scraped_at": "2026-11-14T07:15:49+00:00"
}
```

In Apify Console the **Overview** view shows photo, make, model, year, mileage, price, fuel, gearbox, city, seller type and link. The **Full Details** view adds id, title, currency, source and timestamp.

### 💰 How much does it cost to scrape Finn.no?

Finn.no Scraper uses **pay-per-event** pricing. You pay only for what you get, with no monthly rental:

- **$1.50 per 1,000 listings** saved to the dataset ($0.0015 per listing);
- **$0.005 per run start** (one start event per GB of memory; the default 256 MB counts as one).

Platform usage is included in these prices. Some examples:

| Listings | Approximate cost |
|---|---|
| 50 | $0.08 |
| 1,000 | $1.51 |
| 10,000 (several runs) | about $15 |

With the $5 of free monthly credit on the Apify Free plan you can scrape about 3,000 Finn.no listings a month. Use **Max listings** to put a hard ceiling on what a run can cost.

### ⚠️ Limits

- **2,500 listings per search.** Finn.no serves at most 50 result pages per search; higher page numbers repeat page 1. Finn.no Scraper caps `maxPages` at 50 and removes duplicates. To cover the whole market, run one search per make.
- **Search cards only.** Fields shown only inside each listing (description, equipment, power, colour, VIN) are not extracted.
- **Cars only.** The scraper targets the passenger car search (`registration_class=1`); vans, motorcycles, boats and other Finn.no categories are not covered.
- **Norwegian labels.** Fuel and gearbox values are returned as Finn.no publishes them, without translation.

### 🔗 Related Actors

- [Nettiauto Scraper](https://apify.com/rastriq/nettiauto-scraper) — Finland's car marketplace
- [AutoScout24 Scraper](https://apify.com/rastriq/autoscout24-scraper) — 8 European countries
- [Mobile.de Scraper](https://apify.com/rastriq/mobile-de-scraper) — Germany
- [OtoMoto Scraper](https://apify.com/rastriq/otomoto-scraper) — Poland

### ❓ FAQ

**Is it legal to scrape Finn.no?**
Finn.no Scraper only collects publicly visible listing data, and its search cards contain no seller names or contact details. However, Finn.no's terms and its robots.txt state that automated collection requires Finn.no's written consent. You are responsible for how you use the data: check Finn.no's terms, and get advice if you plan commercial reuse. Do not use the data to contact sellers in bulk.

**Do I need a proxy?**
No. Our test runs used no proxy. If you start seeing HTTP 403 or 429 in the log, add Apify Proxy in the **Advanced** section.

**How do I scrape more than 2,500 cars?**
Finn.no limits every search to 50 pages. Run Finn.no Scraper once per make (for example, one task each for Volvo, Tesla, Toyota and Volkswagen) and merge the datasets.

**Why is `gearbox` empty for electric cars?**
Finn.no shows the driving range instead of the gearbox on most electric car cards, so the field stays empty rather than holding a guess.

**Why are `hp` and `region` always empty?**
They are reserved columns shared with other Rastriq car scrapers. Finn.no does not show them on search results.

**Can I schedule Finn.no Scraper?**
Yes. Save your input as a task and add a schedule in Apify Console. Each run writes a new dataset you can compare with the previous one.

**Something broke. What do I do?**
If a run returns 0 listings it fails on purpose instead of finishing silently. Open an issue on the Actor's **Issues** tab with the run link and we will look into it.

# Changelog

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

# Actor input Schema

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

Optional. Limit the search to one make using Finn.no's internal make code, the value of the <code>variant</code> parameter in a Finn.no car search URL. Examples: <code>0.818</code> = Volvo, <code>0.8078</code> = Tesla, <code>0.813</code> = Toyota, <code>0.817</code> = Volkswagen, <code>0.749</code> = BMW. Leave empty to scrape all makes.

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

How many result pages to crawl. Each page holds about 50 listings. Finn.no serves at most 50 pages (about 2,500 listings) per search, so higher values are capped at 50. To go further, run one search per make.

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

Hard cap on the number of listings saved (and charged). The run stops as soon as it is reached.

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

Optional. Finn.no works without a proxy; tested runs used none. Add Apify Proxy only if you see HTTP 403 or 429 errors in the log.

## Actor input object example

```json
{
  "maxPages": 1,
  "maxItems": 50
}
```

# Actor output Schema

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

All scraped car listings. Each item contains make, model, year, mileage, price (NOK), fuel type, gearbox, city, seller type and image URL.

# 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 = {
    "maxPages": 1,
    "maxItems": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("rastriq/finn-no-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 = {
    "maxPages": 1,
    "maxItems": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("rastriq/finn-no-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 '{
  "maxPages": 1,
  "maxItems": 50
}' |
apify call rastriq/finn-no-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,rastriq/finn-no-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/jkQNb6TBZTnOffkHh/builds/IP8gxCRW0vgBk4mYF/openapi.json
