# Subito.it Scraper - Italy Classifieds & Prices, No Login (`cliqtomedia/subito-listings-scraper`) Actor

Scrape Subito.it classified ads by keyword, category, region and price: title, price, town, photos, condition, seller type and category attributes. Only-new mode for monitoring. No login, cookies or phone numbers.

- **URL**: https://apify.com/cliqtomedia/subito-listings-scraper.md
- **Developed by:** [Cliqto Media](https://apify.com/cliqtomedia) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

Scrape classified ads from [Subito.it](https://www.subito.it/), Italy's biggest classifieds site, by keyword, category, region, price and seller type. Each row has the title, price, town, province, photos, condition, seller type, posting date and the category's own details, such as mileage, year or rooms. No login, cookies or proxy settings. A 20-listing search costs $0.0225 on the Free plan.

Use it to watch prices, find new deals or collect market data from Italy. The smallest run is one keyword, and it finishes in a few seconds. Turn on `onlyNew` and schedule the run to get only new listings each time.

![Subito.it Listings: search "bicicletta" with category, region, price and seller filters, get price, town, condition and photos in one table, then export JSON or CSV](https://api.apify.com/v2/key-value-stores/lReQjCdNJhFHa5PTf/records/HERO.png)

### Table of contents

- [What it does](#what-it-does)
- [Quick start](#quick-start)
- [Use cases](#use-cases)
- [Input](#input)
- [Input examples](#input-examples)
- [Output](#output)
- [Pricing and limits](#pricing-and-limits)
- [API, export and integrations](#api-export-and-integrations)
- [Limits and data notes](#limits-and-data-notes)
- [Troubleshooting](#troubleshooting)
- [FAQ](#faq)
- [Support](#support)

### What it does

The Actor runs the same searches as the Subito.it website and saves one row per listing. You can search by keyword or leave the keyword empty and read a whole category or region. Results come newest first.

Every row has the same columns in every category. The price is a number in euros, and the dates are in UTC. The category details (for example `fuel`, `year` and `mileage` for cars) are in one `features` object. Photo links are always a list.

You can filter by:

- **Keyword**: one search per keyword, such as `bicicletta`, `iphone 13` or `divano`.
- **Category**: 43 Subito.it categories, such as Cars, Apartments, Phones or Bicycles.
- **Region**: one of the 20 Italian regions.
- **Ad type**: for sale, for rent, wanted, holiday rental or giveaway.
- **Price**: minimum and maximum in euros.
- **Seller type**: private people or businesses (shops, dealers, agencies).
- **Only in the title** and **only with Subito shipping**.

#### Good fit

- Track prices of used cars, bikes, phones or furniture in one region.
- Get new listings for a search every day or every hour with `onlyNew`.
- Compare private and business sellers in a category.
- Collect rental or sale listings for a real estate market report.

#### Not a fit

- Seller phone numbers, e-mails or names of private sellers. They are not collected.
- Other classifieds sites, or Subito listings outside Italy.
- More than 10,000 listings for one search. Subito.it shows at most 10,000. Split a big search by region or price to get more.
- Sorting other than newest first.

### Quick start

1. Open the **Input** tab.
2. Keep **Search keywords** as `bicicletta` (the prefill).
3. Keep **Max listings per keyword** at `20`.
4. Click **Start**.
5. Open the **Listings** view of the dataset. Check `title`, `price`, `city` and `postedAt`.

Expected result: the 20 newest bicycle listings in Italy, in about 3 seconds.

### Use cases

| Task | Input | Key fields | Next step |
| --- | --- | --- | --- |
| Watch used car prices in a region | `category: auto`, `region`, `priceMin`, `priceMax` | `price`, `features.year`, `features.mileage_scalar`, `city` | Sort by price in a spreadsheet |
| Get new deals as soon as they appear | `queries` + `onlyNew: true` | `title`, `price`, `url`, `postedAt` | Schedule the run every hour |
| Rental market report | `category: appartamenti`, `adType: rent`, `region` | `price`, `features`, `city`, `province` | Group by `city` |
| Find shops and dealers in a category | `category` + `sellerType: professional` | `shopName`, `city`, `category` | Count listings per `shopName` |

### Input

At least one of `queries`, `category` or `region` is required. Everything else is optional. Keywords that only differ in upper/lower case or spaces are searched once.

| Field | Type | Default / prefill | Allowed values | What it does |
| --- | --- | --- | --- | --- |
| `queries` | array of strings | empty / `["bicicletta"]` | Up to 50 keywords, each up to 200 characters | One search per keyword. Write keywords in Italian, as buyers do. Empty: read the whole `category` and/or `region`. |
| `category` | string | `""` (any) | 43 categories, such as `auto`, `appartamenti`, `telefonia`, `biciclette` | Only listings in this category. Group entries like `motori` (all motors) cover all their categories. |
| `region` | string | `""` (all Italy) | 20 regions, such as `lombardia`, `lazio`, `sicilia` | Only listings in this region. |
| `adType` | string | `sale` | `sale`, `rent`, `wanted`, `holiday`, `gift` | For sale, for rent, wanted ("Cercasi"), holiday rental or giveaway. |
| `priceMin` | integer | empty | 0 or more euros | Only listings with this price or more. |
| `priceMax` | integer | empty | 0 or more euros, not less than `priceMin` | Only listings with this price or less. |
| `maxItems` | integer | `100` / `20` | 1–10,000 | Listings to save for each keyword (or for the category/region search). |
| `onlyNew` | boolean | `false` | true / false | Save (and pay for) only listings that this search did not return before. |
| `sellerType` | string | `all` | `all`, `private`, `professional` | Private people only, or businesses only. |
| `titleOnly` | boolean | `false` | true / false | Match the keyword only in the title, not in the description. |
| `shippingOnly` | boolean | `false` | true / false | Only items the seller ships with Subito delivery. |
| `includeDescription` | boolean | `true` | true / false | Turn off to get smaller rows; `description` is then `null`. |

Wrong input (for example `priceMin` greater than `priceMax`, or no keyword, category or region) stops the run before any request, with a clear message.

#### Settings that work together

- All filters apply to every keyword. 3 keywords with `region: lazio` make 3 searches, all in Lazio.
- `maxItems` applies to each keyword. 3 keywords with `maxItems: 400` can save up to 1,200 listings.
- A listing found by two keywords is saved and charged once, under the first keyword.
- `onlyNew` remembers each search by its keyword and filters. If you change a filter, it is a new search, and the first run returns all listings again (up to `maxItems`).

### Input examples

#### Bicycles, newest first

```json
{"queries":["bicicletta"],"maxItems":20}
```

Returns the 20 newest bicycle listings in Italy. Costs $0.0225 on the Free plan.

#### Used cars from private sellers in Lombardy

```json
{"category":"auto","region":"lombardia","priceMin":3000,"priceMax":6000,"sellerType":"private","maxItems":50}
```

Returns 50 car listings priced €3,000–6,000. `features` has the make and model, year, mileage, fuel, gearbox and power.

#### Daily monitor: only new listings

```json
{"queries":["iphone 13","vespa 125"],"region":"lazio","maxItems":200,"onlyNew":true}
```

The first run returns up to 200 listings per keyword. Each later run returns only the listings added since the run before. If nothing is new, the run saves no rows.

### Output

One dataset row is one listing. The **Listings** view shows the main columns. Download JSON, CSV or Excel from the dataset.

#### Output example

```json
{
  "id": "664528066",
  "urn": "id:ad:8b094273-32b6-4e90-b12f-084df242018c:list:664528066",
  "url": "https://www.subito.it/biciclette/bici-da-corsa-sarto-bologna-664528066.htm",
  "title": "Bici da corsa Sarto",
  "description": "Bicicletta da Corsa Sarto Seta con gruppo Record Campagnolo 10 velocità taglia S orrizontale 52 cm verticale 50 cm",
  "price": 900,
  "currency": "EUR",
  "adType": "sale",
  "adTypeLabel": "In vendita",
  "category": "Biciclette",
  "categoryId": "41",
  "macrocategoryId": "18",
  "region": "Emilia-Romagna",
  "regionId": "8",
  "province": "Bologna",
  "provinceCode": "BO",
  "city": "Bologna",
  "latitude": 44.49411,
  "longitude": 11.341719,
  "postedAt": "2026-10-14T13:14:55.444Z",
  "expiresAt": "2027-10-14T13:14:55.444Z",
  "condition": "Ottimo - poco usato e ben conservato",
  "shippingAvailable": true,
  "features": {
    "bicycle_type": "Uomo",
    "item_condition": "Ottimo - poco usato e ben conservato",
    "item_shippable": "Sì",
    "item_shipping_cost_tuttosubito": "24,90 €"
  },
  "images": [
    "https://images.sbito.it/api/v1/sbt-ads-images-pro/images/91/9118b420-7f13-48e8-b012-72225d03ec81?rule=gallery-desktop-2x-auto",
    "https://images.sbito.it/api/v1/sbt-ads-images-pro/images/c0/c0c24a31-b068-49d1-986e-b42a4452066a?rule=gallery-desktop-2x-auto"
  ],
  "imageCount": 6,
  "sellerType": "private",
  "shopName": null,
  "searchQuery": "bicicletta",
  "source": "subito.it",
  "fetchedAt": "2026-10-14T13:18:22.105Z"
}
```

This is a real row from a `bicicletta` search in October 2026. `features` and `images` are shortened here; the real row has 7 features and 6 photo links. `null` means Subito.it does not show this value for the listing.

#### Output fields

| Field | Type | Can be null? | Meaning |
| --- | --- | --- | --- |
| `id` | string | no | Listing number (the number at the end of the link). |
| `urn` | string | no | Full Subito.it listing ID. |
| `url` | string | no | Listing page on www.subito.it. |
| `title` | string | yes | Listing title. Phone numbers and e-mails in it are masked. |
| `description` | string | yes | Listing text. `null` when `includeDescription` is off. Phone numbers and e-mails are masked. |
| `price` | number | yes | Price in euros. `null` when the listing has no price (never `0` for a missing price). |
| `currency` | string | yes | `EUR`, or `null` when there is no price. |
| `adType` | string | yes | `sale`, `rent`, `wanted`, `holiday` or `gift`. |
| `adTypeLabel` | string | yes | Ad type in Italian, such as `In vendita`. |
| `category` | string | yes | Category name in Italian, such as `Biciclette` or `Auto`. |
| `categoryId`, `macrocategoryId` | string | yes | Subito.it category and category group numbers. |
| `region`, `regionId` | string | yes | Region name and number, such as `Lombardia` / `4`. |
| `province`, `provinceCode` | string | yes | Province, such as `Milano` / `MI`. |
| `city` | string | yes | Town (comune). |
| `latitude`, `longitude` | number | yes | Center of the town, not the seller's address. |
| `postedAt` | string | yes | When the listing was published or last renewed, ISO UTC. |
| `expiresAt` | string | yes | When the listing expires, ISO UTC. |
| `condition` | string | yes | Item condition in Italian, such as `Come nuovo`. Not all categories have it. |
| `shippingAvailable` | boolean | yes | `true` when the seller ships with Subito delivery. |
| `features` | object | no | The category's own details, as `key: value` text. Cars: `year`, `mileage_scalar`, `fuel`, `gearbox`, `power`… Homes: rooms, size, floor… Can be `{}`. |
| `images` | array of strings | no | Photo links (large size). Empty list when there are no photos. |
| `imageCount` | integer | no | Number of photos. |
| `sellerType` | string | yes | `private` or `professional` (shop, dealer, agency). |
| `shopName` | string | yes | Business name. Only for `professional`; always `null` for private sellers. |
| `searchQuery` | string | yes | The keyword that found this listing. `null` for a category or region search without a keyword. |
| `source` | string | no | Always `subito.it`. |
| `fetchedAt` | string | no | When the row was read, ISO UTC. |

#### Run summary

The key-value store record `RUN_SUMMARY` has `status`, `reason`, `message`, counts and one entry per search (status, listings available, pages read, listings saved, listings skipped as already seen). The run's **Output** tab links to it.

| Situation | Dataset | Status / run | What to do |
| --- | --- | --- | --- |
| Listings saved | One row per listing | `COMPLETE`, succeeded | Export the rows. |
| No listings match (or nothing new with `onlyNew`) | Empty | `NO_RESULTS`, succeeded | Check the keyword or try wider filters. |
| Spending limit reached | Rows saved so far | `PARTIAL` + `CHARGE_LIMIT`, succeeded | Raise the maximum cost per run. |
| Run timeout reached | Rows saved so far | `PARTIAL` + `TIME_LIMIT`, succeeded | Raise the timeout or lower `maxItems`. |
| Subito.it failed or blocked the request | Rows saved so far stay | `PARTIAL` or `ERROR` + `SOURCE_ERROR`, failed | Try again later. |
| Invalid input | Empty | `INVALID_INPUT`, failed | Read the message; fix the field it names. |

### Pricing and limits

Pay per event. The price includes platform usage; you pay only the events below.

| Event | Price | When it is charged |
| --- | ---: | --- |
| Actor start | $0.0045 | Once per run. |
| Listing | $0.0009 – $0.00075 | Each saved row. The price depends on your Apify plan (see below). |

| Apify plan | Per listing | 1,000 listings with start |
| --- | ---: | ---: |
| Free | $0.0009 | $0.9045 |
| Bronze | $0.00085 | $0.8545 |
| Silver | $0.0008 | $0.8045 |
| Gold and higher | $0.00075 | $0.7545 |

Listings skipped as duplicates or as already seen (`onlyNew`) are not charged. A run with no results pays only the start.

#### Cost examples (Free plan)

| Scenario | Input | Listings | Total | Time in tests |
| --- | --- | ---: | ---: | ---: |
| Prefill | `bicicletta`, 20 | 20 | $0.0225 | about 3 s |
| One search | 1 keyword, 100 | 100 | $0.0945 | about 5 s |
| Three keywords in one region | 3 × 400, Lazio | 1,200 | $1.0845 | 18 s |
| One big search | 10,000 | 10,000 | $9.0045 | about 3 min |
| No results | an unknown word | 0 | $0.0045 | about 2 s |
| Monitor, nothing new | `onlyNew`, nothing changed | 0 | $0.0045 | a few seconds |

Totals use the listed event prices and the listing counts from test runs.

Set a **maximum cost per run** to control spending. The Actor checks it before saving each page of rows. When the limit is reached, the run stops and keeps the rows saved so far (`CHARGE_LIMIT`, succeeded).

#### Speed and size

- Memory is 256 MB. The Actor reads up to 100 listings per request and makes one request per second, to be polite to Subito.it. In tests this was about 60 listings per second.
- The default timeout is 300 seconds: enough for about 10,000–15,000 listings. In tests, 19,609 listings (two searches) took 332 seconds with a 600-second timeout.
- Up to 10,000 listings per search (the Subito.it limit) and 50 keywords per run.

### API, export and integrations

Start a run with the [Apify API](https://docs.apify.com/api/v2/act-runs-post) and the same JSON input as in the examples:

`POST https://api.apify.com/v2/acts/cliqtomedia~subito-listings-scraper/runs`

Read the default dataset when the run finishes. Export JSON, CSV or Excel. Use `id` as the key when you join rows from different runs. Keep your Apify token private.

To monitor a search, create an [Apify schedule](https://docs.apify.com/platform/schedules) with `onlyNew: true`. Each run then returns only new listings. Add a webhook or an integration (for example Slack, Google Sheets or Zapier) to send the new rows on. This Actor does not create schedules or send alerts itself.

#### Use with AI agents (MCP)

[Apify MCP](https://mcp.apify.com?tools=cliqtomedia/subito-listings-scraper) gives agents access to this Actor. The smallest useful input is:

```json
{"queries":["bicicletta"],"maxItems":20}
```

Key output fields: `title` and `price` (euros, number) describe the offer, `city` and `region` say where it is, `postedAt` says when it was published, and `url` links to the listing. This run takes about 3 seconds and costs $0.0225 on the Free plan. Limits: up to 10,000 listings per search and 50 keywords per run.

### Limits and data notes

- **Search results.** Subito.it decides which listings match a keyword. The Actor does not promise every listing on the site.
- **10,000 per search.** Subito.it shows at most 10,000 results for one search. For bigger categories, split by region or price range.
- **Newest first.** `postedAt` is the publish or renewal time, so a renewed old listing can appear as new.
- **Features.** Keys and values come from Subito.it and are in Italian. Each category has its own keys.
- **Privacy.** Phone numbers, seller user IDs and names of private sellers are never collected. Phone numbers and e-mails typed into the title or text are replaced with `[phone removed]` / `[email removed]`.
- **Changes.** If Subito.it changes its website, a run can fail with `SOURCE_ERROR` until the Actor is updated.

Data comes from the public search pages of [Subito.it](https://www.subito.it/). The [Subito.it terms](https://info.subito.it/policies/condizioni-generali.htm) limit automated access and reuse of its content. You are responsible for checking that your use of the data is allowed. This Actor is an independent tool. It is not made by or endorsed by Subito.it.

### Troubleshooting

#### The dataset is empty

Open `RUN_SUMMARY`. `NO_RESULTS` means Subito.it has no listing for this keyword and these filters. Check the spelling, write the keyword in Italian, or remove a filter. With `onlyNew`, it can also mean that nothing is new since the last run.

#### `onlyNew` returns all listings again

`onlyNew` remembers a search by its keyword and all its filters. If you change a filter, it is a new search with an empty history, so the first run returns all listings again (up to `maxItems`). Keep the same input for each scheduled run.

#### The run stopped early

`CHARGE_LIMIT` means the maximum cost per run was reached; raise it. `TIME_LIMIT` means the run timeout was reached; raise the timeout or lower `maxItems`. In both cases the run succeeds and keeps the saved rows.

#### The run failed with `SOURCE_ERROR`

Subito.it did not answer after several tries, or refused the request. Rows saved before the error stay in the dataset. Wait a few minutes and try again.

### FAQ

#### Do I need a Subito.it account or a proxy?

No. The Actor reads public search results. You only need an Apify account.

#### Can I get the seller's phone number?

No. Phone numbers and contact details are not collected, and those typed into the text are masked. Use the `url` to contact the seller on Subito.it.

#### Does a search with no results cost money?

Only the start: $0.0045. Rows are charged only when they are saved.

#### Can I search all of Italy?

Yes. Leave `region` empty. To read a whole category without a keyword, leave `queries` empty and set `category`.

#### How do I get price history?

Each run gives the current listings. Schedule the same input and keep the datasets. Use `id` to follow one listing over time.

### Support

Open an issue in this Actor's **Issues** tab. Include the run ID, your input and the message from `RUN_SUMMARY`. Never share your Apify token.

# Changelog

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

# Actor input Schema

## `queries` (type: `array`):

One search per keyword, in Italian as buyers type it (e.g. "bicicletta", "iphone 13", "divano"). Leave empty to browse a whole category or region.

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

Limit to one Subito.it category. "(all)" entries cover the whole group.

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

Limit to one Italian region.

## `adType` (type: `string`):

For sale (default), for rent, wanted ("Cercasi"), holiday rental or giveaway.

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

Only ads priced at or above this, in whole euros.

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

Only ads priced at or below this, in whole euros.

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

Upper limit of listings saved for each keyword (newest first). Subito.it shows at most 10,000 per search.

## `onlyNew` (type: `boolean`):

Remembers what this search returned before and saves (and charges) only listings you have not received yet. Use it with a schedule to monitor a search.

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

All sellers, private people only, or businesses (shops, dealers, agencies) only.

## `titleOnly` (type: `boolean`):

Ignore matches in the description text.

## `shippingOnly` (type: `boolean`):

Only items the seller ships with Subito delivery.

## `includeDescription` (type: `boolean`):

Turn off for smaller rows. Phone numbers and e-mails in the text are always masked.

## Actor input object example

```json
{
  "queries": [
    "bicicletta"
  ],
  "category": "",
  "region": "",
  "adType": "sale",
  "maxItems": 20,
  "onlyNew": false,
  "sellerType": "all",
  "titleOnly": false,
  "shippingOnly": false,
  "includeDescription": true
}
```

# Actor output Schema

## `listings` (type: `string`):

Subito.it listings as a table.

## `runSummary` (type: `string`):

Status, per-search counts, totals available and request statistics.

# 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 = {
    "queries": [
        "bicicletta"
    ],
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("cliqtomedia/subito-listings-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 = {
    "queries": ["bicicletta"],
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("cliqtomedia/subito-listings-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 '{
  "queries": [
    "bicicletta"
  ],
  "maxItems": 20
}' |
apify call cliqtomedia/subito-listings-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,cliqtomedia/subito-listings-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/L2N3FaVXxgoqJuJdT/builds/7apthDdncBiA1sPNG/openapi.json