# Subito Scraper - Italian Listings, Prices & Sellers (`s-r/subito-scraper`) Actor

Scrape public Subito.it listings by keyword or search URL. Get prices, condition, photos, descriptions, locations, seller and shipping fields. Filter by category, region, province and price. Paginated JSON, CSV or Excel exports.

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

## Pricing

from $1.00 / 1,000 listings

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

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Subito Scraper - Italian Listings, Prices & Sellers

Subito Scraper collects public Subito.it classified listings by keyword or a pasted search URL.
Export each unique listing to JSON, CSV or Excel with its asking price, original Italian
condition label, photos, full description, location, public seller details and shipping fields.
Use it for used-goods price monitoring, regional market research and listing comparisons.

Subito.it is Italy's largest general classifieds marketplace: phones, electronics, furniture,
cars, motorbikes, property, jobs and more, posted by private people and businesses in every
region. This Subito.it scraper works across all of those categories with one input, so the
same run can cover a single model in one province or a whole category across Italy.

### What you get from the Subito scraper

- One row per unique ad, with the listing id, title, link and position in the search results
- Asking price as a number in EUR, plus the price text as shown on the site
- Condition label in Italian (for example "Buono - usato ma ben conservato") and its code
- Town, province, region and municipality coordinates
- All photo URLs, the photo count and the full ad description
- Private or business seller, shop name for business sellers, and shipping options and cost
- Category, ad type, posting and expiry dates, and category-specific attributes

### Subito Scraper input

Provide a keyword with `query`, or paste a search-results URL into `search_url`. For example,
this keyword was measured against the live source and is also covered by real saved responses:

```json
{"query": "iphone 13", "max_items": 300}
```

A pasted URL can retain category, region, province, municipality, shipping, seller and price
filters. This search was measured on Subito and returns listings from Bergamo province:

```json
{"search_url":"https://www.subito.it/annunci-lombardia/vendita/telefonia/bergamo/?q=iphone+13&shp=true&ps=100&pe=300&advt=0","max_items":100}
```

`search_url` takes precedence over the keyword and separate filter inputs. Without a URL,
you can set `category`, `region`, `province`, `price_min`, `price_max`, `condition`,
`seller_type`, `shipping_only`, `title_only` and `sort`. Category and region accept Subito
slugs or ids. A province requires a region. The default ad type is for_sale; giveaways,
rentals, holiday rentals and wanted ads are also supported. The default result limit is 100.

### Output

Each dataset row is one unique listing. Core fields are `listing_id`, `title`, `url`, `price`,
`currency`, `country`, `condition`, `image_url`, `position`, `source` and `fetched_at`.
Prices are numbers in EUR, and absent prices remain null. A zero asking price stays zero.
Condition labels remain in Italian; an absent label stays null. No model matcher removes
accessories or related products returned by Subito's search.

Additional fields include `description`, `images`, `image_count`, `category`, `category_id`,
`town`, `town_id`, `province`, `province_code`, `region`, `latitude`, `longitude`, `posted_at`,
`expires_at`, `seller_id`, `seller_name`, `seller_type`, `shop_id`, `shop_name`, `shippable`,
`shipping_type`, `shipping_cost`, `is_urgent` and category-specific `attributes`.
Coordinates identify the municipality centre. Public descriptions retain Subito's phone
masks, and a seller name is present only when the public search response supplies it.

The run summary reports source totals, pages collected and `free_tier_remaining`. Paying
users receive -1 for that remaining-cap field. When the source has fewer listings than
requested, the actor returns the available rows. Collection failures preserve completed
pages and report the interruption instead of creating replacement records.

#### Example Subito scraper output

This is a real row returned for the Bergamo search URL shown above (fetched on 5 October 2026,
private seller, shipping available):

```json
{
  "source": "subito-scraper",
  "fetched_at": "2026-10-05T10:13:20.530Z",
  "listing_id": "662958211",
  "urn": "id:ad:f20bd0c3-0ff8-4993-9150-c81b8a0df9ef:list:662958211",
  "title": "Iphone 13 128gb",
  "url": "https://www.subito.it/telefonia/iphone-13-128gb-bergamo-662958211.htm",
  "price": 220,
  "price_text": "220 €",
  "currency": "EUR",
  "country": "IT",
  "condition": "Buono - usato ma ben conservato",
  "condition_code": "40",
  "location": "Bergamo, Lombardia",
  "town": "Premolo",
  "town_id": "016175",
  "province": "Bergamo",
  "province_code": "BG",
  "region": "Lombardia",
  "latitude": 45.868644,
  "longitude": 9.875382,
  "description": "Prezzo trattabile, buone condizioni, batteria sostituita circa un anno fa",
  "category": "Telefonia",
  "category_id": "12",
  "ad_type": "In vendita",
  "ad_type_code": "s",
  "image_url": "https://images.sbito.it/api/v1/sbt-ads-images-pro/images/25/25cd9b6a-8552-4ee5-9642-d30aca0ab94a?rule=fullscreen-1x-auto",
  "images": [
    "https://images.sbito.it/api/v1/sbt-ads-images-pro/images/25/25cd9b6a-8552-4ee5-9642-d30aca0ab94a?rule=fullscreen-1x-auto",
    "https://images.sbito.it/api/v1/sbt-ads-images-pro/images/af/afe1ce86-92d4-4170-9e91-94ea77c0d25c?rule=fullscreen-1x-auto",
    "https://images.sbito.it/api/v1/sbt-ads-images-pro/images/2a/2a8c7f93-9643-46f7-a643-5885e8f95bff?rule=fullscreen-1x-auto"
  ],
  "image_count": 3,
  "posted_at": "2026-10-02T08:08:06.246+0200",
  "expires_at": "2027-10-02T08:08:06.246+0200",
  "seller_id": "104876224",
  "seller_name": null,
  "seller_type": "private",
  "shop_id": null,
  "shop_name": null,
  "shippable": true,
  "shipping_type": "Spedizione con TuttoSubito",
  "shipping_cost": 0.99,
  "is_urgent": false,
  "attributes": {
    "Corrieri per la spedizione": "poste_italiane",
    "Disponibile alla spedizione": "Sì",
    "Peso del pacco": "Piccolo - fino a 2kg",
    "Tipologia telefoni": "Cellulari e Smartphone"
  },
  "query": "iphone 13",
  "page": 1,
  "position": 3
}
```

### Use cases for the Subito scraper

- **Used-goods price research.** Collect every ad for a phone, console, bike or appliance model
  and compute the going rate by condition, region or seller type.
- **Resellers and refurbishers.** Track which models are listed below your buying price and
  how many business sellers compete in a province.
- **Car and motorbike market monitoring.** Export vehicle ads with their category attributes
  to compare asking prices across regions.
- **Regional market studies.** Count supply per region or province for a category and follow
  it week by week with scheduled runs.
- **Lead lists of business sellers.** Business ads carry the shop name, so you can see which
  shops are active in a category or area.
- **Alerts and dashboards.** Run a saved search URL on a schedule, sorted by newest, and push
  the new rows to Google Sheets, a webhook or your own database.

### Subito Scraper vs. the Subito API and DIY scripts

Subito does not publish an open listings API for third parties, so the usual options are a
hosted scraper, a self-written script, or copying ads by hand.

| Option | Coverage | Maintenance | Output |
|---|---|---|---|
| This Subito scraper | All categories, keyword or search URL, up to 10,000 rows per search | None on your side | Clean JSON, CSV or Excel rows |
| Open-source scripts | Usually one page or one category | You fix it when the site changes | Raw or partial fields |
| Category-specific Store actors | Cars, property or jobs only | Varies | Varies |
| Manual copy | A handful of ads | Your time | Spreadsheet by hand |

The main difference is scope: one input format for every category, filters taken straight from
a pasted Subito URL, automatic pagination with deduplication, and no inferred values. Prices,
condition labels and seller fields are exactly what the public listing shows.

### How to scrape Subito.it in three steps

1. Search on Subito.it with the filters you want, then copy the address bar URL, or just type
   a keyword into `query`.
2. Set `max_items` to the number of listings you need (paid plans up to 10,000 per run).
3. Start the run and download the dataset as JSON, CSV or Excel, or read it with the Apify API.

### Pricing

The proposed pay-per-event rate is **$0.001 per delivered listing** plus **$0.0005 per run start**.
Only unique rows actually delivered to the dataset count as listing events. A search with
no results has no listing charge; its run-start event remains. Free-plan users can collect
up to **10 listings per run**. Paid-plan users can request up to 10,000 listings, subject to
source availability. Final pricing is configured on the actor before publication.

At that rate 1,000 delivered listings cost about $1 plus the start fee.

### Pagination and limits

The actor follows continuation pages automatically. Each request has a bounded time budget,
and subsequent requests continue at the first uncollected offset. Duplicate listing ids are
removed across pages and request chunks. Subito only serves the first 10,000 source records
for a single search even when its displayed total is larger. Narrow a large search with
category, geography or price filters. New listings can move offsets while a run is in
progress; deduplication prevents repeated delivery, but cannot freeze the live catalogue.
With ascending-price order, ads without an asking price may appear first.

### FAQ

#### Can I use a search URL instead of a keyword?

Yes. Paste a public Subito search URL whose path starts with /annunci-. Listing-detail URLs
are not search inputs. A nationwide unfiltered catalogue URL is rejected; add a keyword,
category or region. Unsupported URL parameters are rejected so filters never disappear silently.

#### Does this provide seller phone numbers or email addresses?

The actor returns the public search response. Phone masks in descriptions remain masked.
It does not request private contact details or seller reputation information.

#### Why did I receive fewer rows than max_items?

The source can have fewer matching ads, duplicate records, or a 10,000-record offset cap.
Temporary source failures can also interrupt a run. Check the summary and warnings, and
narrow a broad query or retry an interrupted collection.

#### What does the free-plan cap mean?

Accounts without a paid Apify plan receive at most ten dataset rows per run. Paid-plan
accounts bypass this cap. Both cases bill the rows delivered, using the actor's configured
pay-per-event model.

#### Is condition translated or inferred?

No. Condition is the original Italian source label or null when absent. The output also
contains its source code when available. Prices and seller attributes are never inferred
from the title.

#### Which Subito categories does it support?

All public search categories, including electronics, home and garden, vehicles, property and
jobs. Set `category` with a Subito slug or id, or paste a search URL from any category.

#### Can I run it on a schedule?

Yes. Save the input as an Apify task and add a schedule, for example every morning with
sort set to newest. Each run returns the listings found at that moment.

# Actor input Schema

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

Search keyword, for example iphone 13. Provide query or search_url.

## `search_url` (type: `string`):

Paste a public Subito /annunci- search URL. Its query and filters take precedence.

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

Category slug or id from Subito, such as telefonia or 12.

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

Italian region slug or id, such as lombardia or 4.

## `province` (type: `string`):

Province slug within region, such as bergamo. Requires region.

## `ad_type` (type: `string`):

Type of classified ad.

## `price_min` (type: `integer`):

Minimum asking price in EUR.

## `price_max` (type: `integer`):

Maximum asking price in EUR.

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

Condition filter. Output keeps the original Italian label.

## `seller_type` (type: `string`):

Include all sellers, private sellers or businesses.

## `shipping_only` (type: `boolean`):

Only listings that offer shipping.

## `title_only` (type: `boolean`):

Search only listing titles.

## `sort` (type: `string`):

Result order. Listings without a price may come first with price_asc.

## `max_items` (type: `integer`):

Maximum unique listings. Apify follows cursors automatically; API clients follow next_cursor.

## `cursor` (type: `string`):

Opaque next_cursor from a previous response for the same search and filters.

## Actor input object example

```json
{
  "query": "iphone 13",
  "ad_type": "for_sale",
  "seller_type": "all",
  "shipping_only": false,
  "title_only": false,
  "sort": "newest",
  "max_items": 100
}
```

# Actor output Schema

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

One row per unique listing.

## `summary` (type: `string`):

Total results, fetched pages and remaining free rows.

# 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 13"
};

// Run the Actor and wait for it to finish
const run = await client.actor("s-r/subito-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 13" }

# Run the Actor and wait for it to finish
run = client.actor("s-r/subito-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 '{
  "query": "iphone 13"
}' |
apify call s-r/subito-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,s-r/subito-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/4l3mB0WYRCg5NxlNn/builds/zxlX542dIKHNSQPSp/openapi.json