# Tori.fi Listings Scraper (Finland) (`xtracto/tori-fi-listings`) Actor

Scrape classified listings from tori.fi, Finland's largest marketplace: title, price, condition, location, listing age, images and promoted-ad flags. No login, no browser.

- **URL**: https://apify.com/xtracto/tori-fi-listings.md
- **Developed by:** [Farhan Febrian Nauval](https://apify.com/xtracto) (community)
- **Categories:** E-commerce
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.33 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

## Tori.fi Listings Scraper: Finland's Largest Classifieds

Extract search results from tori.fi, Finland's largest classifieds site: title, price, condition, location, listing age, images, brand and promoted-ad flags.

### Why use this actor

- **No account, no login, no API key.** Type a search term and run.
- **Location and listing age on every row**, plus an approximate posting time in UTC.
- **Prices as numbers.** Finnish formatting (`1 234,50 €`) is converted correctly to `1234.5`.
- **Promoted ads flagged, not hidden.** Paid pole-position ads are kept and marked with `isPromoted`, or switched off with one checkbox.
- **Searches in Finnish or English**, several terms per run.
- **Stable JSON output** for price tracking, market research and spreadsheets. Export to JSON, CSV or Excel, and schedule runs on Apify.

### How it works

1. Enter one or more search terms, such as `auto`, `polkupyörä` or `iphone`.
2. The actor runs each search on tori.fi and reads the results page by page (about 54 listings per page).
3. Each listing becomes one row with its price, condition, location, age, images and flags.
4. The run stops at your per-search limit.

You do not need to manage scrapers, browsers or blocks.

### Input

```json
{
  "searchQueries": ["auto", "polkupyörä"],
  "maxItemsPerQuery": 100,
  "includePromoted": true,
  "proxyConfiguration": { "useApifyProxy": true }
}
```

| Field | Type | Description |
|---|---|---|
| `searchQueries` | array | One search per entry, in Finnish or English. |
| `maxItemsPerQuery` | integer | Maximum listings per search. About 54 listings per page. |
| `includePromoted` | boolean | Keep paid pole-position ads (flagged with `isPromoted`). Switch off to exclude them. |
| `proxyConfiguration` | object | Optional. Data-centre proxies work and help with larger runs. |

### Output

One row per listing. Real output for the search `polkupyörä` (bicycle):

```json
{
  "_input": "polkupyörä",
  "_source": "S2-card-only",
  "_scrapedAt": "2026-11-11T13:12:07Z",
  "adId": "49046553",
  "url": "https://www.tori.fi/recommerce/forsale/item/49046553",
  "title": "Jamis Nova Race 58 Cyclocross / Gravel-pyörä (UUDENVEROINEN / AJAMATON)",
  "description": null,
  "price": 445.0,
  "currency": "EUR",
  "condition": null,
  "availability": null,
  "brand": null,
  "location": "Tuomarila-Suvela, Espoo",
  "ageLabel": "4 pv",
  "ageValue": 4,
  "ageUnit": "days",
  "postedAtApprox": "2026-11-07T13:12:07Z",
  "badges": [],
  "isPromoted": false,
  "hasStructuredData": false,
  "imageUrl": "https://img.tori.net/dynamic/default/item/49046553/05a0b0d8-9dbf-45d2-989e-981f04f3c107",
  "imageCount": 8
}
```

Another row from the same run, where the listing carried full detail:

```json
{
  "adId": "47576572",
  "title": "Polkupyörä",
  "description": "Polkupyörä",
  "price": 220.0,
  "currency": "EUR",
  "condition": "Used",
  "availability": "InStock",
  "location": "Kaleva, Tampere",
  "ageLabel": "1 min",
  "ageValue": 1,
  "ageUnit": "minutes",
  "postedAtApprox": "2026-11-11T13:11:07Z",
  "hasStructuredData": true,
  "imageCount": 2
}
```

| Field | Type | Description |
|---|---|---|
| `adId`, `url` | string | Listing id and link |
| `title`, `description` | string | Listing title and short description |
| `price`, `currency` | number / string | Asking price and currency (`EUR`) |
| `condition`, `availability`, `brand` | string | Item details, when tori.fi publishes them for the listing |
| `location` | string | Neighbourhood and city |
| `ageLabel` | string | tori.fi's own age label: `23 min`, `8 t` (hours), `6 pv` (days) |
| `ageValue`, `ageUnit` | number / string | The age as a number and unit |
| `postedAtApprox` | string | Approximate posting time in UTC, worked out from the age label |
| `badges` | array | Badges on the listing card, e.g. `Paalupaikka` |
| `isPromoted` | boolean | True for paid pole-position ads |
| `hasStructuredData` | boolean | True when condition, availability and brand were available for this listing |
| `imageUrl`, `imageCount` | string / number | Main image and image count |
| `_input`, `_source`, `_scrapedAt` | string | Your search term, which parts of the page filled the row, and the time of the scrape |
| `_error` | string | Only on failures, see below |

### Notes and limits

- **A `price` of 0 means no asking price was published.** It can be a wanted ad, a "make an offer" listing or a giveaway, and the page does not say which. Exclude zeros before averaging prices.
- **`postedAtApprox` is an estimate** from tori.fi's relative label, so the raw `ageLabel` is included beside it. Promoted ads often have no age at all.
- **Condition, availability and brand are missing on some rows.** tori.fi publishes them for most listings but not all, mostly not for promoted ads. `hasStructuredData` tells you which rows have them.
- **Error rows** carry `_error`: `invalid_input` (empty search term), `no_results` (the search returned nothing), `unexpected_shape` (the page layout changed), `not_found`, `blocked` or `network_error`. If every search fails, the run fails rather than finishing empty.

# Actor input Schema

## `searchQueries` (type: `array`):

One search per entry, in Finnish or English — auto, polkupyörä, iphone.

## `maxItemsPerQuery` (type: `integer`):

About 54 listings per page.

## `includePromoted` (type: `boolean`):

Paid pole-position ads. They are kept by default and flagged with isPromoted, since they are real listings; switch this off to exclude them.

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

Datacenter proxies work. Useful for larger runs.

## Actor input object example

```json
{
  "searchQueries": [
    "auto",
    "polkupyörä"
  ],
  "maxItemsPerQuery": 100,
  "includePromoted": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

One row per scraped record, stored in the run's default dataset.

# 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 = {
    "searchQueries": [
        "auto",
        "polkupyörä"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("xtracto/tori-fi-listings").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 = { "searchQueries": [
        "auto",
        "polkupyörä",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("xtracto/tori-fi-listings").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 '{
  "searchQueries": [
    "auto",
    "polkupyörä"
  ]
}' |
apify call xtracto/tori-fi-listings --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,xtracto/tori-fi-listings"
        }
    }
}
```

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/lTpwOHGbWx7uOXcIg/builds/0uWdzW7DIuwBhKizg/openapi.json
