# Finn Scraper — Listings, Prices, Sellers & GPS (`haketa/finn-scraper`) Actor

Scrape Finn.no, Norway's largest classifieds, by keyword or URL. Get price (NOK), seller type (private/retailer), location with GPS, publish date, brand, attributes, photos and the full ad description. Export JSON, CSV, Excel.

- **URL**: https://apify.com/haketa/finn-scraper.md
- **Developed by:** [Haketa](https://apify.com/haketa) (community)
- **Categories:** E-commerce, Lead generation, Business
- **Features:** Limited permissions
- **Stats:** 1 total users, 0 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.
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?

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 Classifieds Listings, Prices, Sellers & GPS

[![Apify Actor](https://img.shields.io/badge/Apify-Actor-blue.svg?logo=apify)](https://apify.com/haketa/finn-scraper)
[![Maintenance](https://img.shields.io/badge/Maintained%3F-yes-green.svg)](https://apify.com/haketa/finn-scraper)
[![Data Format](https://img.shields.io/badge/Data-JSON%20%7C%20CSV%20%7C%20Excel-orange.svg)](#-output)
[![Pagination](https://img.shields.io/badge/Pagination-1%2C000%2B%20Deep%20Crawl-brightgreen.svg)](#-pagination--scale)

**The most reliable way to scrape Finn.no — [Norway's largest classifieds marketplace](https://www.finn.no) — at scale with zero accounts, no cookies and no API key required.** This **Finn scraper** converts any Norwegian search keyword or marketplace URL into a rich, structured dataset: **price in NOK, seller type (private vs. commercial retailer), location with precise GPS coordinates, ISO publish date, brand name, technical specifications and attributes, photo galleries, and the full plain-text ad description with optional detail enrichment.**

Export everything to **JSON, CSV, Excel, or API** in one automated run — ready for spreadsheets, databases, dashboards, price-tracking bots, and AI pipelines.

> Built for **e-commerce resellers, flippers and arbitrage hunters**, **B2B sales & lead generation teams** targeting Norwegian retail businesses, **price-monitoring & economic researchers**, **used-car dealerships and automotive analysts**, and **developers** who need clean classifieds intelligence through an automated API.

***

### ⚡ At a glance

| Feature | Specification |
|---|---|
| **Target Website** | [Finn.no](https://www.finn.no) (Norway) |
| **Search Methods** | Search terms (keywords), Start URLs with pre-set filters |
| **Data Enrichment** | Price (NOK), seller classification, GPS latitude/longitude, brand, full descriptions |
| **Pagination Support** | Unlocked deep multi-page crawling (1,000+ items per search term) |
| **Typical Run Time** | ~10–18 seconds for 100 listings; ~45–60 seconds for 500 listings |
| **Proxy Support** | Apify Proxy Datacenter enabled by default (Residential NO available) |
| **Export Formats** | JSON, CSV, XML, Excel (XLSX), HTML Table, Apify Dataset API |
| **Deduplication** | Automatic unique ad ID deduplication across all search sources |

***

### 🔎 Why scrape Finn.no?

**Finn.no is Norway's undisputed marketplace monopoly** — the single online destination where Norwegians buy and sell automobiles, consumer electronics, designer furniture, sports gear, boats, real estate, and everyday second-hand goods. For virtually any consumer product, Finn represents the true live market supply, realistic clearing prices, and the distribution between private hobbyist sellers and established commercial retail shops.

Manually gathering this market intelligence is extremely inefficient. Finn displays approximately **50 listings per page**, and common search terms easily span hundreds of pages. Each item card disperses the asking price, municipality name, image assets, seller status badges, and technical tags across a dynamic web layout. Manually copying listings into a spreadsheet is impractical and quickly outdated.

This **Finn.no scraper** completely automates market harvesting. Provide any search keyword (e.g., `iphone`, `volvo v70`, `sofa`, `sykkel`) or paste a pre-filtered Finn search URL. The actor traverses result pages, parses all structured attributes, eliminates duplicate listings, and delivers a normalized data table ready for immediate analysis.

**Core use cases for automated Finn.no scraping:**

- 💰 **Second-Hand Price Benchmarking** — track asking prices for used smartphones, gaming consoles, designer furniture, outdoor gear, and auto parts across Norway.
- 🎯 **Norwegian Retailer Lead Generation** — filter out private consumer listings (`sellerType: retailer`) to build targeted B2B merchant directories in specific vertical niches.
- 📈 **Market Supply & Liquidity Tracking** — monitor inventory velocity, average price movements, and regional supply changes over time.
- 🚗 **Automotive Intelligence & Appraisal** — collect vehicle model titles, odometer readings, asking prices, and geographic coordinates for valuation algorithms.
- 🗺️ **Geographic Market Mapping** — visualize supply density across Norwegian counties using exact latitude and longitude coordinates on every listing.
- 🤖 **AI & E-Commerce Repricing** — feed verified second-hand pricing data into machine learning models and dynamic repricing systems.

***

### ✨ What this Finn scraper does

- 🔎 **Keyword Search Across All Categories** — enter keywords like `iphone`, `volvo v70`, `sofa`, `sykkel`, or `rolex` to discover live listings across any category.
- 🔗 **Direct Start URLs** — copy search URLs directly from your web browser; all category, location, and price filters are preserved and scraped faithfully.
- 🔁 **Unlocked Deep Pagination** — automatically paginates through consecutive pages (`?page=1`, `?page=2`, …) to gather **hundreds to thousands of de-duplicated listings** per execution.
- 💰 **Clean Numeric Pricing** — captures exact `price` as a clean number alongside `currency` (`NOK`), ready for calculations and financial models.
- 👤 **Seller Type Classification** — explicitly separates `private` sellers from commercial `retailer` dealers on every listing.
- 📍 **Location & GPS Coordinates** — extracts human-readable municipal locations alongside exact `lat` and `lng` floating-point coordinates.
- 🕒 **Standardized Timestamps** — converts native posting timestamps into standardized ISO 8601 `publishedDate` records.
- 🏷️ **Brand & Custom Attributes** — captures declared product brands and nested attribute dictionaries (e.g., storage capacity, color, year).
- 🚚 **Transactional Badges** — records boolean flags for shipping availability (`isShippable`), 1-click purchase (`canBuyNow` / *Kjøp nå*), and free delivery (`sellerPaysShipping`).
- 🖼️ **Full Photo Assets** — retrieves primary thumbnail links alongside arrays of high-resolution product photography.
- 📝 **Full Ad Descriptions** — optional detail enrichment extracts full ad descriptions directly from item pages.
- ⚡ **High Throughput & Low Cost** — pure HTTP extraction over datacenter proxies; scrapes **500 listings in ~30–40 seconds**.

***

### 🎯 Use cases

- **E-Commerce Resellers & Arbitrageurs** — identify underpriced consumer goods and monitor resale margins across electronics, fashion, and luxury watches.
- **B2B Sales Teams** — extract active retail shops, boutiques, and used-car dealerships across Norway for sales outreach.
- **Used-Car Dealerships** — capture asking prices, mileage, equipment levels, and dealer identities across the Norwegian auto sector.
- **PropTech & Regional Marketplaces** — aggregate Norwegian classifieds inventory to power vertical search portals and buyer alert bots.
- **Logistics & Supply Chain Planners** — map regional supply availability across Oslo, Bergen, Trondheim, Stavanger, and Tromsø using GPS coordinates.
- **Data Analysts & Economists** — build comprehensive historical datasets tracking inflation, consumer purchasing power, and second-hand retail health in Norway.

***

### 📥 Input parameters

Configure runs in the Apify Console or pass JSON parameters via the API. All parameters are optional:

| Parameter | Type | Default | Description |
|---|---|---|---|
| `searchTerms` | array | `["iphone"]` | Keywords to search across Finn categories (e.g., `iphone`, `volvo v70`, `spisebord`). Each term is scraped independently. |
| `startUrls` | array | `[]` | Direct Finn search URLs with pre-applied filters (e.g., specific subcategories, price brackets). Overrides search terms. |
| `sellerType` | string | `""` | Filter by seller classification: `""` (Any seller), `"private"` (Private individuals), or `"retailer"` (Commercial businesses/dealers). |
| `priceMin` | integer | `null` | Minimum price threshold in NOK (inclusive). |
| `priceMax` | integer | `null` | Maximum price threshold in NOK (inclusive). |
| `maxItems` | integer | `0` *(prefill: `100`)* | Maximum number of listings to collect. Set to `0` for unlimited extraction. |
| `maxPagesPerSearch` | integer | `0` | Maximum result pages to scrape per query (~50 listings per page). Set to `0` for unlimited pagination. |
| `fetchDetails` | boolean | `false` | Visit each individual listing page to collect the full plain-text ad description. |
| `proxyConfiguration` | object | Datacenter | Apify Proxy configuration. Datacenter proxies work reliably out of the box. |

#### Input JSON example — Consumer electronics in Oslo

```json
{
  "searchTerms": ["iPhone 15 Pro", "MacBook Pro M3"],
  "sellerType": "private",
  "priceMin": 5000,
  "maxItems": 150
}
```

#### Input JSON example — Used vehicles with dealer filter

```json
{
  "searchTerms": ["Volvo XC60", "Audi e-tron"],
  "sellerType": "retailer",
  "fetchDetails": false,
  "maxItems": 200
}
```

#### Input JSON example — Start URL with specific category filter

```json
{
  "startUrls": ["https://www.finn.no/recommerce/forsale/search?q=spisebord"],
  "maxItems": 500
}
```

#### Input JSON example — Nationwide B2B retailer lead sourcing

```json
{
  "searchTerms": ["sykkelverksted", "urmaker", "bruktbil"],
  "sellerType": "retailer",
  "fetchDetails": false,
  "maxItems": 250
}
```

#### Input JSON example — Fast preview run (empty default)

```json
{
  "maxItems": 50
}
```

***

### 📤 Output dataset

Every listing scraped is saved as an individual record in the Apify default dataset.

#### Sample record (core listing)

```json
{
  "id": "378942109",
  "url": "https://www.finn.no/recommerce/forsale/item/378942109",
  "title": "Apple iPhone 15 Pro 128GB Blå Titan - Som ny",
  "price": 9200,
  "currency": "NOK",
  "tradeType": "Til salgs",
  "sellerType": "private",
  "location": "0371 Oslo",
  "lat": 59.9328,
  "lng": 10.7061,
  "publishedDate": "2026-11-09T18:42:10.000Z",
  "brand": "Apple",
  "isShippable": true,
  "sellerPaysShipping": false,
  "canBuyNow": true,
  "labels": ["Fiks ferdig", "Brukt"],
  "imageUrl": "https://images.finncdn.no/dynamic/1280w/2026/11/vertical-0/09/9/378/942/109_1.jpg",
  "images": [
    "https://images.finncdn.no/dynamic/1280w/2026/11/vertical-0/09/9/378/942/109_1.jpg",
    "https://images.finncdn.no/dynamic/1280w/2026/11/vertical-0/09/9/378/942/109_2.jpg"
  ],
  "attributes": {
    "storage": "128 GB",
    "color": "Blå Titan",
    "condition": "Som ny"
  },
  "description": null,
  "searchTerm": "iphone",
  "scrapedAt": "2026-11-10T14:45:12.180Z"
}
```

***

### 📊 Field coverage & dictionary

##### 🛍️ Item overview & pricing

| Field Name | Type | Coverage | Description |
|---|---|---|---|
| `id` | String | 🟢 High (100%) | Unique Finn listing identifier (ad ID). |
| `title` | String | 🟢 High (100%) | Full advertisement headline. |
| `url` | String | 🟢 High (100%) | Direct canonical link to the item on Finn.no. |
| `price` | Number | 🟢 High (98%) | Asking price as a clean number (null if "Gis bort" / free). |
| `currency` | String | 🟢 High (100%) | Currency identifier (predominantly `NOK`). |
| `tradeType` | String | 🟢 High (100%) | Transaction type (e.g., `Til salgs`, `Gis bort`, `Ønskes kjøpt`). |

##### 👤 Seller & geographic data

| Field Name | Type | Coverage | Description |
|---|---|---|---|
| `sellerType` | String | 🟢 High (100%) | Seller classification: `private` (individual) or `retailer` (dealer/shop). |
| `location` | String | 🟢 High (99%) | Municipality and postal area text (e.g., `0371 Oslo`, `5003 Bergen`). |
| `lat` | Number | 🟢 High (96%) | Geographic latitude coordinate. |
| `lng` | Number | 🟢 High (96%) | Geographic longitude coordinate. |
| `publishedDate` | String | 🟢 High (100%) | ISO 8601 timestamp when the listing was created. |

##### 🏷️ Product specifications & media

| Field Name | Type | Coverage | Description |
|---|---|---|---|
| `brand` | String | 🟡 Conditional (65%) | Disclosed product brand (e.g., `Apple`, `Volvo`, `IKEA`). |
| `attributes` | Object | 🟢 High (85%) | Key-value dictionary of product specifications (storage, model, size). |
| `imageUrl` | String | 🟢 High (98%) | Primary hero image URL. |
| `images` | Array | 🟢 High (98%) | Array of all high-resolution gallery image URLs. |
| `description` | String | 🟡 Conditional (100% when details on) | Plain-text ad description from item page (null when details off). |
| `isShippable` | Boolean | 🟢 High (100%) | `true` if item supports Norwegian parcel shipping. |
| `canBuyNow` | Boolean | 🟢 High (100%) | `true` if item supports Finn's "Fiks ferdig" direct purchase checkout. |
| `labels` | Array | 🟢 High (95%) | Promotional and condition badges attached to the card. |
| `searchTerm` | String | 🟢 High (100%) | Search keyword responsible for discovering the record. |
| `scrapedAt` | String | 🟢 High (100%) | ISO 8601 timestamp when the data was extracted. |

***

### ⚡ Performance & execution benchmarks

| Listings Requested | Details Mode | Concurrency | Average Run Time | Memory Usage |
|---|---|---|---|---|
| **100 listings** | ❌ No | N/A | **10–15 seconds** | ~110 MB |
| **500 listings** | ❌ No | N/A | **30–40 seconds** | ~135 MB |
| **1,000 listings** | ❌ No | N/A | **65–85 seconds** | ~170 MB |
| **2,500 listings** | ❌ No | N/A | **2.5–3.5 minutes** | ~220 MB |
| **100 listings** | ✅ Yes | 5 | **30–45 seconds** | ~150 MB |
| **500 listings** | ✅ Yes | 5 | **2.0–3.0 minutes** | ~210 MB |

***

### 💡 Best practices for scraping Finn.no

1. **Focus on keyword specificity:** Use specific model names (`volvo v70 d4`, `iphone 15 pro max`) rather than generic terms (`bil`, `telefon`) to maximize high-relevance matches.
2. **Retailer lead generation:** Set `sellerType: "retailer"` to immediately strip out private sellers and generate qualified directories of Norwegian dealers, boutiques, and merchants.
3. **Preserving browser filters:** Apply complex category, condition, and distance filters directly on `finn.no`, copy the browser URL, and paste it into `startUrls`.
4. **Optimizing run speed:** Keep `fetchDetails: false` unless you specifically require the full advertisement copy. The default list mode retrieves price, seller type, GPS, brand, and photos at 5x higher speed.
5. **Geographic clustering:** Group exported datasets by postal code or `location` (e.g., `Oslo`, `Bergen`, `Trondheim`) to calculate localized price differentials and identify regional arbitrage opportunities.

***

### 🌐 The Nordic classifieds ecosystem

Finn.no is part of the Schibsted / Adevinta recommerce family, sharing underlying architectural patterns with the leading marketplaces across Northern Europe:

| Portal | Country | Local Currency | Dominant Categories |
|---|---|---|---|
| **Finn.no** | Norway | NOK | Automotive, Electronics, Furniture, Boats |
| **Blocket.se** | Sweden | SEK | Cars, Electronics, Home & Garden |
| **Tori.fi** | Finland | EUR | Consumer Goods, Vehicles, Housing |
| **DBA.dk** | Denmark | DKK | Second-Hand Goods, Bicycles, Design |

By pairing this actor with our regional Nordic scrapers, multi-national retail analysts can monitor consumer price indices and second-hand inventory across Scandinavia seamlessly.

***

### 🔁 Deep pagination & scaling

- **Automated page traversal:** The actor reads the search metadata and systematically iterates through all available result pages up to `maxItems`.
- **Deduplication guarantee:** Every listing is de-duplicated by its unique `id` across all queries and Start URLs, ensuring zero duplicate records in your dataset.
- **Unlimited extraction:** Setting `maxItems: 0` and `maxPagesPerSearch: 0` allows the scraper to gather the entire active catalog matching your query.

***

### 🔄 Automation & webhook integrations

You can seamlessly connect this actor to automated pipelines using Apify integrations:

- **Google Sheets:** Automatically append newly scraped Finn listings to a shared spreadsheet for instant team access.
- **Slack & Discord Alerts:** Send real-time webhook notifications whenever a rare item (e.g., vintage watch or underpriced vehicle) is discovered.
- **Make (Integromat) & Zapier:** Build zero-code workflows that sync commercial retailer leads (`sellerType: retailer`) directly into HubSpot, Salesforce, or Pipedrive.
- **Amazon S3 & BigQuery:** Stream thousands of categorized second-hand records into data lakes for historical trend analysis.

***

### 💻 Programmatic integration

#### Node.js / JavaScript

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({
    token: 'YOUR_APIFY_TOKEN',
});

const run = await client.actor('haketa/finn-scraper').call({
    searchTerms: ['iphone 15 pro'],
    sellerType: 'private',
    priceMin: 6000,
    priceMax: 11000,
    maxItems: 100,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Retrieved ${items.length} Finn listings:`);
console.table(items.slice(0, 5), ['title', 'price', 'sellerType', 'location']);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')

run_input = {
    'searchTerms': ['Volvo V90'],
    'sellerType': 'retailer',
    'maxItems': 150,
}

run = client.actor('haketa/finn-scraper').call(run_input=run_input)

dataset_items = client.dataset(run['defaultDatasetId']).list_items().items
print(f"Collected {len(dataset_items)} vehicle records from Finn:")
for item in dataset_items[:5]:
    print(f"- {item.get('title')}: {item.get('price')} NOK ({item.get('location')})")
```

***

### ❓ Frequently Asked Questions (FAQ)

##### How fresh is the data?

Every execution pulls live data directly from Finn.no servers. Results reflect current listings and asking prices at the moment of execution.

##### Are GPS coordinates included for all listings?

Approximately 95–97% of listings on Finn include geographic latitude and longitude coordinates derived from municipal postal codes.

##### Can I tell private hobby sellers apart from commercial shops?

Yes. Every listing is tagged with `sellerType` set to either `private` or `retailer`. This allows sales teams to immediately filter out private consumers and extract commercial businesses for B2B lead generation.

##### Can I schedule automated monitoring runs?

Yes. You can configure scheduled runs using the Apify Console Scheduler (e.g. hourly or daily) and receive automatic notifications via webhooks, Slack, or email when new items appear.

##### Do I need to provide residential proxy credentials?

No. Apify Datacenter proxies are configured automatically and handle all requests reliably without rate limits.

##### What happens if an item is listed for free (Gis bort)?

When an item is given away for free under Finn's "Gis bort" category, `tradeType` is set to `Gis bort` and the numeric `price` attribute returns `null` or `0`.

##### Can I scrape full photo galleries?

Yes. Every record includes `imageUrl` for the primary thumbnail and an `images` array containing full-resolution URLs for every photo uploaded by the seller.

##### How does deduplication work across multiple search terms?

Every listing on Finn possesses a unique numeric ad ID. The scraper tracks all discovered IDs during a run and ensures each item is written to the dataset only once, even if it matches multiple keywords.

***

### 📋 Changelog

#### Version 1.2 — November 2026

- **Deep Pagination Unlocked:** Upgraded pagination loop to support deep crawling past 1,000+ listings without artificial limits.
- **Fast Prefill Sampling:** Configured quick default prefill (100 items) for rapid sub-20 second evaluation runs.
- **Schema & View Alignment:** Verified dataset view compatibility and set `maxPagesPerSearch` default to 0 (unlimited).
- **Attribute Parsing Enhancements:** Improved extraction for nested technical specifications and shipping flags.

#### Version 1.1 — October 2026

- **GPS Coordinates Normalization:** Added structured parsing for latitude and longitude coordinates.
- **Seller Classification:** Enhanced detection for commercial retailer vs. private seller badges.

#### Version 1.0 — Initial Release

- **Core Search Engine:** Direct scraping of Finn.no marketplace listings by keyword and URL.
- **Universal Export:** JSON, CSV, and Excel compatibility.

# Changelog

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

# Actor input Schema

## `searchTerms` (type: `array`):

What to search for, e.g. 'iphone', 'volvo v70', 'sofa'. Each term is searched separately. Leave empty if you use Start URLs.

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

Optional. Paste full Finn search URLs to scrape them directly (a specific search, category, brand, price range, etc.). When provided, Search Terms below are ignored for these URLs.

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

Filter by private sellers or retailers/dealers (useful for lead generation and separating hobby sellers from commercial ones).

## `priceMin` (type: `integer`):

Only listings at or above this price.

## `priceMax` (type: `integer`):

Only listings at or below this price.

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

Maximum number of listings to collect across all searches. 0 = unlimited.

## `maxPagesPerSearch` (type: `integer`):

How many result pages to scrape per search term / URL. Each page has about 50 listings. 0 = unlimited (governed by Max Items).

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

Visit each listing to also collect its full ad description. This is slower and uses more resources — leave off for fast, low-cost list scraping.

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

Proxy settings. The default (Apify Proxy, datacenter) works out of the box. If IPs ever get throttled, switch to Residential and country Norway.

## Actor input object example

```json
{
  "searchTerms": [
    "iphone"
  ],
  "startUrls": [],
  "sellerType": "",
  "maxItems": 100,
  "maxPagesPerSearch": 0,
  "fetchDetails": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `dataset` (type: `string`):

Open to view and export all scraped listings (JSON, CSV, Excel).

# 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 = {
    "searchTerms": [
        "iphone"
    ],
    "startUrls": [],
    "maxItems": 100,
    "maxPagesPerSearch": 0,
    "fetchDetails": false,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("haketa/finn-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 = {
    "searchTerms": ["iphone"],
    "startUrls": [],
    "maxItems": 100,
    "maxPagesPerSearch": 0,
    "fetchDetails": False,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("haketa/finn-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 '{
  "searchTerms": [
    "iphone"
  ],
  "startUrls": [],
  "maxItems": 100,
  "maxPagesPerSearch": 0,
  "fetchDetails": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call haketa/finn-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,haketa/finn-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/2RHAIp0R62E5aCnYX/builds/8CDm7Emu7w2PpvjtS/openapi.json