# Finn Torget Scraper 1$/1k (`trev0n/finn-torget-scraper`) Actor

Scrape listings from finn.no Torget — Norway's biggest classifieds marketplace. Filter by category, condition, price, region and seller type, pull full descriptions, and run cheap incremental monitoring that emits only new/updated/changed listings.

- **URL**: https://apify.com/trev0n/finn-torget-scraper.md
- **Developed by:** [Paweł](https://apify.com/trev0n) (community)
- **Categories:** Automation, Developer tools, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

## 🛒 FINN Torget Scraper

🎯 **Pull clean, structured listing data from FINN Torget — Norway's biggest classifieds marketplace — in seconds.**

This scraper collects everything you see on finn.no/torget: titles, prices, conditions, locations, images, seller type, shipping options and full descriptions — across all 11 categories and every Norwegian county. Search by keyword, filter exactly how you want, and export ready-to-use data. Built-in **monitoring mode** lets you watch the market and pay only for what actually changes.

### 🚀 What Does It Do?

This scraper automatically searches FINN Torget and collects **structured, ready-to-use data** for every matching listing. No manual browsing, no copy-paste — just set your filters and hit Start.

💡 **Two ways to run it:**

1. **🔍 Search Mode** — Give it a keyword (like `iphone` or `sofa`) and/or filters (category, condition, price, region, seller type) and it gathers every matching listing, page after page.
2. **🔁 Monitoring Mode** — Schedule it to run daily or hourly and it returns **only the listings that are new or changed** since last time — perfect for deal hunting and price tracking without re-downloading the whole market every run.

### 👥 Who Is This For?

| 🏢 Use Case                 | 💬 How It Helps                                                               |
| --------------------------- | ----------------------------------------------------------------------------- |
| 🛍️ **Resellers & flippers** | Spot underpriced items the moment they appear and act before anyone else      |
| 📊 **Price analysts**       | Track how prices move across categories, regions and conditions over time     |
| 🏷️ **Dealers & shops**      | Monitor competitor listings and benchmark your own pricing                    |
| 🔎 **Deal hunters**         | Get alerted to fresh listings matching your exact criteria                    |
| 🤖 **AI & data teams**      | Feed clean marketplace data into models, dashboards or recommendation engines |
| 📦 **Market researchers**   | Measure supply, demand and seasonality across Norway's second-hand economy    |

### ✨ Features

- 🇳🇴 **Full Torget coverage** — All 11 categories, every Norwegian county, private sellers and dealers
- 🎛️ **Smart Filters** — Keyword, category, condition, price range, region, seller type, ad type, brand, "Fiks ferdig" only, and posted-today
- 📝 **Full descriptions** — Optionally pull each item's complete description, category path and attributes
- 🔁 **Incremental Monitoring** — On recurring runs, get only new / changed / reappeared listings and cut your costs by 80–95%
- 🔔 **Instant Alerts** — Push new listings straight to Telegram, Discord, Slack or your own webhook
- 💸 **Price-drop detection** — Monitoring mode flags listings whose price changed since you last looked
- 🧹 **Clean, consistent output** — Tidy field names, structured prices and ISO timestamps on every record
- 🗺️ **Geo data** — Latitude/longitude for every listing for mapping and distance analysis
- ⚡ **Fast & Scalable** — Thousands of listings per run, straight from the source
- 🧯 **Deduplication** — Every listing appears once, even across multiple pages and searches
- 📤 **Export Anywhere** — Download results as JSON, CSV, Excel, or push to Google Sheets, Zapier, Make, or your CRM

### 🎛️ Filters & Options

| Option                            | What It Does                                                              |
| --------------------------------- | ------------------------------------------------------------------------- |
| 🔤 **Search keywords**            | Find listings matching a word or phrase (e.g. `iphone`, `sofa`, `sykkel`) |
| 🗂️ **Category**                   | Limit results to one of the 11 top-level Torget categories                |
| 🏅 **Condition**                  | New, as-new, good, worn, or needs-repair                                  |
| 📍 **Region**                     | Narrow to a single Norwegian county (fylke)                               |
| 👤 **Seller type**                | Private sellers only, or dealers only                                     |
| 🏷️ **Ad type**                    | For sale, giving away (free), or wanted-to-buy                            |
| 🏭 **Brand**                      | Keep only a specific brand (e.g. Apple, IKEA)                             |
| 🚚 **Fiks ferdig only**           | Only listings with built-in shipping & secure payment                     |
| 🆕 **Posted today**               | Only listings published today                                             |
| 💰 **Price range**                | Set a minimum and/or maximum price in NOK                                 |
| ↕️ **Sort by**                    | Relevance, newest, oldest, price up, price down, or closest               |
| ➕ **Include / exclude keywords** | Fine-tune results by required or banned words                             |
| ⏱️ **Max age**                    | Drop listings older than a chosen number of minutes                       |
| 🔢 **Max results**                | Control how many listings to collect per run                              |
| 🔗 **Direct URLs**                | Optionally provide specific FINN search or item URLs to scrape            |

### 🔁 Save Big With Monitoring Mode

If you run this scraper on a schedule (e.g. every morning to catch fresh deals), **Monitoring Mode** is where the savings are.

The **first run** builds a baseline of everything matching your search. **Every run after that** compares the market to that baseline and returns **only what's different**:

- 🆕 **NEW** — listings that weren't there before
- ✏️ **UPDATED** — listings whose price or details changed (great for catching price drops)
- 🔁 **REAPPEARED** — listings that were gone and came back
- ♻️ **Repost detection** — spots the same item re-listed under a new id, so you're not fooled by duplicates

Because you only pay for the listings that actually changed, a daily monitor of an active search typically costs **80–95% less** than re-scraping the whole list every day. Turn it on with a single switch (**Incremental monitoring mode**), schedule the run in the Apify Console, and optionally connect Telegram, Discord, Slack or a webhook to get pinged the second something new shows up.

💡 **Example:** Monitoring 500 listings daily. After the first run, only ~25 change on a typical day — so each following run handles ~25 records instead of 500. Over a month that's a fraction of the cost of full daily re-scrapes, while you still see every new deal the moment it lands.

### 📦 What You Get (Output Fields)

Every listing includes:

#### Core Info

| Field        | Example                                                              |
| ------------ | -------------------------------------------------------------------- |
| itemId       | `467415020`                                                          |
| title        | `Apple iPhone 11 128 GB grønn`                                       |
| url          | `https://www.finn.no/recommerce/forsale/item/467415020`              |
| brand        | `Apple`                                                              |
| condition    | `new`                                                                |
| categoryPath | `Elektronikk og hvitevarer > Telefoner og tilbehør > Mobiltelefoner` |

#### Pricing & Trade

| Field           | Example     |
| --------------- | ----------- |
| price           | `2500`      |
| priceCurrency   | `NOK`       |
| priceUnit       | `kr`        |
| tradeType       | `Til salgs` |
| fiksFerdig      | `true`      |
| buyNowAvailable | `true`      |
| sellerType      | `private`   |

#### Location

| Field     | Example   |
| --------- | --------- |
| location  | `Oslo`    |
| latitude  | `59.9139` |
| longitude | `10.7522` |

#### Media & Timing

| Field      | Example                                                        |
| ---------- | -------------------------------------------------------------- |
| image      | `https://images.finncdn.no/dynamic/default/item/467415020/...` |
| imageCount | `3`                                                            |
| postedAt   | `2026-06-18T17:46:45.000Z`                                     |
| scrapedAt  | `2026-06-19T11:00:00.000Z`                                     |

#### Full Details (when enabled)

| Field             | Example                                                               |
| ----------------- | --------------------------------------------------------------------- |
| description       | `Selger en grønn iPhone 11 med 128 GB lagring. Face ID, stor skjerm…` |
| descriptionLength | `159`                                                                 |
| attributes        | `{ "category": "…", "size": "Andre" }`                                |

#### Monitoring (in incremental mode)

| Field       | Example                    |
| ----------- | -------------------------- |
| changeType  | `NEW`                      |
| firstSeenAt | `2026-06-19T11:00:00.000Z` |
| lastSeenAt  | `2026-06-19T11:00:00.000Z` |
| isRepost    | `false`                    |

### 📊 Example Output

```json
{
    "itemId": "467415020",
    "title": "Apple iPhone 11 128 GB grønn",
    "url": "https://www.finn.no/recommerce/forsale/item/467415020",
    "searchQuery": "iphone",
    "price": 2500,
    "priceCurrency": "NOK",
    "priceUnit": "kr",
    "tradeType": "Til salgs",
    "location": "Oslo",
    "latitude": 59.9139,
    "longitude": 10.7522,
    "brand": "Apple",
    "memorySize": "128 GB",
    "sellerType": "private",
    "fiksFerdig": true,
    "shippingAvailable": true,
    "buyNowAvailable": true,
    "labels": ["Fiks ferdig", "Kjøp nå", "Privat"],
    "image": "https://images.finncdn.no/dynamic/default/item/467415020/d84ddc40.jpg",
    "imageUrls": [
        "https://images.finncdn.no/dynamic/default/item/467415020/d84ddc40.jpg",
        "https://images.finncdn.no/dynamic/default/item/467415020/11f25bc0.jpg"
    ],
    "imageCount": 3,
    "condition": "new",
    "categoryPath": "Elektronikk og hvitevarer > Telefoner og tilbehør > Mobiltelefoner",
    "description": "Selger en grønn iPhone 11 med 128 GB lagring. Face ID og stor skjerm. Pent brukt, ingen riper.",
    "descriptionLength": 159,
    "attributes": { "category": "Elektronikk og hvitevarer > Telefoner og tilbehør > Mobiltelefoner", "size": "Andre" },
    "postedAt": "2026-06-18T17:46:45.000Z",
    "changeType": "NEW",
    "firstSeenAt": "2026-06-19T11:00:00.000Z",
    "lastSeenAt": "2026-06-19T11:00:00.000Z",
    "isRepost": false,
    "scrapedAt": "2026-06-19T11:00:00.000Z"
}
````

### 📋 Dataset Views

The Apify Console gives you **4 ready-made table views** to quickly browse your results:

| View                | What It Shows                                              |
| ------------------- | ---------------------------------------------------------- |
| 📊 **Overview**     | Title, price, location, condition, seller and posted date  |
| 🔁 **Monitoring**   | Change type, price, first/last seen — for incremental runs |
| 💸 **Deals**        | Price, ad type, "Fiks ferdig", buy-now and seller signals  |
| 📋 **Full Details** | Every single field — the complete dataset                  |

### ❓ FAQ

**🤔 Does it cover all of FINN Torget?**
Yes — all 11 top-level categories and every Norwegian county, including both private sellers and dealers.

**🤔 Can I track price drops?**
Yes. In monitoring mode, a listing whose price changes since your last run comes back tagged as `UPDATED`, so you can catch price drops automatically.

**🤔 How do the savings on recurring runs work?**
After the first (baseline) run, monitoring mode returns only listings that are new or changed — so you're not paying to re-download everything every day. On an active search that's typically 80–95% cheaper than full re-scrapes.

**🤔 Can I get notified about new listings?**
Yes — connect Telegram, Discord, Slack or a custom webhook and the scraper pings you whenever new or updated listings appear.

**🤔 Can I export the data?**
Yes — JSON, CSV, Excel, XML, HTML, RSS. You can also push data directly to Google Sheets, Zapier, Make, or any webhook/API endpoint.

**🤔 How often should I run this?**
For fresh data, run daily or weekly. You can schedule automatic runs on Apify with just a few clicks — and monitoring mode keeps those runs cheap.

**🤔 Does it work with proxies?**
Yes — it runs fine without a proxy, and residential proxies are supported for large or very frequent runs via Apify's built-in proxy service.

### 🛠️ Need Custom Filters or Features?

**I'm happy to customize this scraper for your specific needs!** 🤝

Whether you need:

- 🎯 Additional filters (specific sub-categories, multiple keywords at once, saved-search style watchlists)
- 📊 Extra data fields or custom output formats
- 🔄 Integration with your CRM, Google Sheets, or database
- ⏰ Scheduled scraping with automatic deduplication and alerting
- 🌐 Scraping from other Nordic classifieds platforms alongside FINN

👉 **Don't hesitate to reach out via private message** — I respond quickly and I'm always open to building exactly what you need. No request is too small or too specific!

### ⚖️ Legal & Ethical Use

This scraper collects **only publicly available information** from FINN Torget. It does not access private data, bypass authentication, or contact sellers on your behalf. Please use the data responsibly and in compliance with applicable laws and platform terms of service.

# Actor input Schema

## `query` (type: `string`):

What to search for on Torget (e.g. "iphone", "sofa", "sykkel"). Leave empty to browse by category/region only or to use Start URLs.

## `category` (type: `string`):

Limit results to one top-level Torget category.

## `condition` (type: `string`):

Filter by item condition.

## `region` (type: `string`):

Limit results to one Norwegian county.

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

Show only private sellers or only dealers.

## `tradeType` (type: `string`):

For-sale ads, free giveaways, or wanted ads.

## `brand` (type: `string`):

Optional brand filter (e.g. "Apple", "IKEA"). The brand name is matched automatically against the available brands; pick a category too for the best match.

## `fiksFerdig` (type: `boolean`):

Only listings that support FINN's built-in shipping & secure payment ("Fiks ferdig").

## `publishedToday` (type: `boolean`):

Only listings published today.

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

Lower bound of the price range, in Norwegian kroner.

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

Upper bound of the price range, in Norwegian kroner (0 = no limit).

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

Ordering of search results.

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

Optional FINN Torget search-result or item URLs to scrape directly instead of (or alongside) a keyword search.

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

Maximum number of listings to collect (0 = unlimited).

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

Cap on result pages to fetch per search (0 = no cap). FINN serves at most 50 pages per search.

## `includeKeywords` (type: `array`):

Keep only listings whose title/description/brand contains at least one of these terms.

## `excludeKeywords` (type: `array`):

Drop listings whose title/description/brand contains any of these terms.

## `maxAgeMinutes` (type: `integer`):

Drop listings older than this many minutes by posted date (0 = no limit).

## `includeDetails` (type: `boolean`):

Fetch each item's full description, category path and attributes from its page. Slower but much richer.

## `descriptionMaxLength` (type: `integer`):

Truncate descriptions to this many characters (0 = no limit).

## `compact` (type: `boolean`):

Output only the core fields — handy for AI workflows.

## `excludeEmptyFields` (type: `boolean`):

Omit null / empty fields from each record.

## `detailConcurrency` (type: `integer`):

How many item-detail requests to run in parallel (1-20). Higher is faster.

## `useProxyForDetails` (type: `boolean`):

Route full-detail page requests through the proxy. Off by default — item pages load far faster fetched directly. Turn on only if you start hitting rate limits.

## `incrementalMode` (type: `boolean`):

Track state across runs and emit only NEW / UPDATED / REAPPEARED listings. The first run builds a baseline; later runs charge only for the diff — ideal for cheap recurring monitoring.

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

Custom identifier for the monitoring baseline. Leave empty to derive it from the search config automatically.

## `emitUnchanged` (type: `boolean`):

Also output listings whose content didn't change since the last run.

## `emitExpired` (type: `boolean`):

Also output a record for listings that disappeared since the last run (changeType = EXPIRED).

## `skipReposts` (type: `boolean`):

Drop new listings detected as reposts of a recently expired one (same content, new id).

## `notifyOnlyChanges` (type: `boolean`):

Only send notifications when there are new/updated listings.

## `notificationLimit` (type: `integer`):

Maximum number of listings listed in a single notification message.

## `includeRunSummary` (type: `boolean`):

Attach the run summary object to the generic webhook payload.

## `webhookUrl` (type: `string`):

Generic webhook to POST results to (JSON).

## `telegramBotToken` (type: `string`):

Telegram bot token for notifications.

## `telegramChatId` (type: `string`):

Telegram chat id to send notifications to.

## `discordWebhookUrl` (type: `string`):

Discord channel webhook for notifications.

## `slackWebhookUrl` (type: `string`):

Slack incoming webhook for notifications.

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

Proxy settings. The API works without a proxy, but a proxy helps for large or frequent runs.

## Actor input object example

```json
{
  "query": "iphone",
  "category": "",
  "condition": "",
  "region": "",
  "sellerType": "",
  "tradeType": "",
  "fiksFerdig": false,
  "publishedToday": false,
  "priceMin": 0,
  "priceMax": 0,
  "sortBy": "relevance",
  "maxResults": 100,
  "maxPages": 0,
  "maxAgeMinutes": 0,
  "includeDetails": false,
  "descriptionMaxLength": 0,
  "compact": false,
  "excludeEmptyFields": false,
  "detailConcurrency": 10,
  "useProxyForDetails": false,
  "incrementalMode": false,
  "emitUnchanged": false,
  "emitExpired": false,
  "skipReposts": false,
  "notifyOnlyChanges": true,
  "notificationLimit": 10,
  "includeRunSummary": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `overview` (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 = {
    "query": "iphone"
};

// Run the Actor and wait for it to finish
const run = await client.actor("trev0n/finn-torget-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 = { "query": "iphone" }

# Run the Actor and wait for it to finish
run = client.actor("trev0n/finn-torget-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "query": "iphone"
}' |
apify call trev0n/finn-torget-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=trev0n/finn-torget-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Finn Torget Scraper 1$/1k",
        "description": "Scrape listings from finn.no Torget — Norway's biggest classifieds marketplace. Filter by category, condition, price, region and seller type, pull full descriptions, and run cheap incremental monitoring that emits only new/updated/changed listings.",
        "version": "1.0",
        "x-build-id": "64UbXMMCgPcj9mu29"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/trev0n~finn-torget-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-trev0n-finn-torget-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/trev0n~finn-torget-scraper/runs": {
            "post": {
                "operationId": "runs-sync-trev0n-finn-torget-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/trev0n~finn-torget-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-trev0n-finn-torget-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "query": {
                        "title": "Search keywords",
                        "type": "string",
                        "description": "What to search for on Torget (e.g. \"iphone\", \"sofa\", \"sykkel\"). Leave empty to browse by category/region only or to use Start URLs."
                    },
                    "category": {
                        "title": "Category",
                        "enum": [
                            "",
                            "antiques-art",
                            "pets",
                            "electronics",
                            "parenting-children",
                            "leisure-hobby",
                            "garden-renovation",
                            "clothing-cosmetics",
                            "furniture-interior",
                            "business",
                            "sports-outdoors",
                            "vehicle-parts"
                        ],
                        "type": "string",
                        "description": "Limit results to one top-level Torget category.",
                        "default": ""
                    },
                    "condition": {
                        "title": "Condition",
                        "enum": [
                            "",
                            "new",
                            "as-new",
                            "good",
                            "worn",
                            "needs-repair"
                        ],
                        "type": "string",
                        "description": "Filter by item condition.",
                        "default": ""
                    },
                    "region": {
                        "title": "Region (fylke)",
                        "enum": [
                            "",
                            "agder",
                            "akershus",
                            "buskerud",
                            "finnmark",
                            "innlandet",
                            "more-og-romsdal",
                            "nordland",
                            "oslo",
                            "rogaland",
                            "svalbard",
                            "telemark",
                            "troms",
                            "trondelag",
                            "vestfold",
                            "vestland",
                            "ostfold"
                        ],
                        "type": "string",
                        "description": "Limit results to one Norwegian county.",
                        "default": ""
                    },
                    "sellerType": {
                        "title": "Seller type",
                        "enum": [
                            "",
                            "private",
                            "dealer"
                        ],
                        "type": "string",
                        "description": "Show only private sellers or only dealers.",
                        "default": ""
                    },
                    "tradeType": {
                        "title": "Ad type",
                        "enum": [
                            "",
                            "for-sale",
                            "giving-away",
                            "wanted"
                        ],
                        "type": "string",
                        "description": "For-sale ads, free giveaways, or wanted ads.",
                        "default": ""
                    },
                    "brand": {
                        "title": "Brand",
                        "type": "string",
                        "description": "Optional brand filter (e.g. \"Apple\", \"IKEA\"). The brand name is matched automatically against the available brands; pick a category too for the best match."
                    },
                    "fiksFerdig": {
                        "title": "Fiks ferdig only",
                        "type": "boolean",
                        "description": "Only listings that support FINN's built-in shipping & secure payment (\"Fiks ferdig\").",
                        "default": false
                    },
                    "publishedToday": {
                        "title": "Posted today only",
                        "type": "boolean",
                        "description": "Only listings published today.",
                        "default": false
                    },
                    "priceMin": {
                        "title": "Minimum price (NOK)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Lower bound of the price range, in Norwegian kroner.",
                        "default": 0
                    },
                    "priceMax": {
                        "title": "Maximum price (NOK)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Upper bound of the price range, in Norwegian kroner (0 = no limit).",
                        "default": 0
                    },
                    "sortBy": {
                        "title": "Sort by",
                        "enum": [
                            "relevance",
                            "newest",
                            "oldest",
                            "price-asc",
                            "price-desc",
                            "closest"
                        ],
                        "type": "string",
                        "description": "Ordering of search results.",
                        "default": "relevance"
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Optional FINN Torget search-result or item URLs to scrape directly instead of (or alongside) a keyword search.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of listings to collect (0 = unlimited).",
                        "default": 100
                    },
                    "maxPages": {
                        "title": "Max pages per search",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Cap on result pages to fetch per search (0 = no cap). FINN serves at most 50 pages per search.",
                        "default": 0
                    },
                    "includeKeywords": {
                        "title": "Include keywords",
                        "type": "array",
                        "description": "Keep only listings whose title/description/brand contains at least one of these terms.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "excludeKeywords": {
                        "title": "Exclude keywords",
                        "type": "array",
                        "description": "Drop listings whose title/description/brand contains any of these terms.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxAgeMinutes": {
                        "title": "Max age (minutes)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Drop listings older than this many minutes by posted date (0 = no limit).",
                        "default": 0
                    },
                    "includeDetails": {
                        "title": "Include full item details",
                        "type": "boolean",
                        "description": "Fetch each item's full description, category path and attributes from its page. Slower but much richer.",
                        "default": false
                    },
                    "descriptionMaxLength": {
                        "title": "Description max length",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Truncate descriptions to this many characters (0 = no limit).",
                        "default": 0
                    },
                    "compact": {
                        "title": "Compact output",
                        "type": "boolean",
                        "description": "Output only the core fields — handy for AI workflows.",
                        "default": false
                    },
                    "excludeEmptyFields": {
                        "title": "Exclude empty fields",
                        "type": "boolean",
                        "description": "Omit null / empty fields from each record.",
                        "default": false
                    },
                    "detailConcurrency": {
                        "title": "Detail concurrency",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "How many item-detail requests to run in parallel (1-20). Higher is faster.",
                        "default": 10
                    },
                    "useProxyForDetails": {
                        "title": "Use proxy for detail pages",
                        "type": "boolean",
                        "description": "Route full-detail page requests through the proxy. Off by default — item pages load far faster fetched directly. Turn on only if you start hitting rate limits.",
                        "default": false
                    },
                    "incrementalMode": {
                        "title": "Incremental monitoring mode",
                        "type": "boolean",
                        "description": "Track state across runs and emit only NEW / UPDATED / REAPPEARED listings. The first run builds a baseline; later runs charge only for the diff — ideal for cheap recurring monitoring.",
                        "default": false
                    },
                    "stateKey": {
                        "title": "State key",
                        "type": "string",
                        "description": "Custom identifier for the monitoring baseline. Leave empty to derive it from the search config automatically."
                    },
                    "emitUnchanged": {
                        "title": "Emit unchanged listings",
                        "type": "boolean",
                        "description": "Also output listings whose content didn't change since the last run.",
                        "default": false
                    },
                    "emitExpired": {
                        "title": "Emit expired listings",
                        "type": "boolean",
                        "description": "Also output a record for listings that disappeared since the last run (changeType = EXPIRED).",
                        "default": false
                    },
                    "skipReposts": {
                        "title": "Skip reposts",
                        "type": "boolean",
                        "description": "Drop new listings detected as reposts of a recently expired one (same content, new id).",
                        "default": false
                    },
                    "notifyOnlyChanges": {
                        "title": "Notify only on changes",
                        "type": "boolean",
                        "description": "Only send notifications when there are new/updated listings.",
                        "default": true
                    },
                    "notificationLimit": {
                        "title": "Listings per notification",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of listings listed in a single notification message.",
                        "default": 10
                    },
                    "includeRunSummary": {
                        "title": "Include run summary in webhook",
                        "type": "boolean",
                        "description": "Attach the run summary object to the generic webhook payload.",
                        "default": true
                    },
                    "webhookUrl": {
                        "title": "Webhook URL",
                        "type": "string",
                        "description": "Generic webhook to POST results to (JSON)."
                    },
                    "telegramBotToken": {
                        "title": "Telegram bot token",
                        "type": "string",
                        "description": "Telegram bot token for notifications."
                    },
                    "telegramChatId": {
                        "title": "Telegram chat ID",
                        "type": "string",
                        "description": "Telegram chat id to send notifications to."
                    },
                    "discordWebhookUrl": {
                        "title": "Discord webhook URL",
                        "type": "string",
                        "description": "Discord channel webhook for notifications."
                    },
                    "slackWebhookUrl": {
                        "title": "Slack webhook URL",
                        "type": "string",
                        "description": "Slack incoming webhook for notifications."
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy settings. The API works without a proxy, but a proxy helps for large or frequent runs.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
