# Subito.it Scraper - Cars, Real Estate, New Ads & Price Drops (`neverempty/subito-it-scraper`) Actor

For car dealers and property investors: Subito.it ads by keyword, category, region, price, car year, mileage, private or business seller: price, town, date, photos, car/home details. 16 of 30 newest Lombardia cars were old ads re-dated (2026-09-25); monitor returns only new ads and price drops.

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

## Pricing

from $2.80 / 1,000 listing returneds

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

## Subito.it Scraper - Cars, Real Estate, New Ads & Price Drops

Get **Subito.it listings** (Italy's biggest classifieds site) as clean JSON: title, price, description, category, **region, province and town**, date listed, photo, **private or business seller** (with the dealer's shop name), and for vehicles the **brand, model, version, registration year, mileage, fuel, gearbox and power**, for property the **size in m², rooms, bathrooms, floor and energy class**. Search by **search term**, **category** (auto, moto-e-scooter, appartamenti, telefonia ...), **region or province**, **price range**, **car year and mileage**, **private or business sellers**, or paste Subito search URLs with any filter you set in the browser. Turn on **Monitor mode** and scheduled runs return **only new ads and price drops** since the last check - so a car dealer, a reseller, a deal alert or a Telegram/Slack bot gets the new ones without paying for the same listings again.

- **New ads monitor that does not sell old ads as new.** Subito sorts by "posted or bumped to the top", so older ads come back to the top of the list every day (in our check on 2026-09-25, 16 of the 30 "newest" cars in Lombardia were older ads with a fresh date, one of them a 1964 Fiat 1500 Coupé). Monitor mode tells them apart with Subito's listing numbers (they grow with every new ad), the listing date and the showcase (In vetrina) mark, and returns as `changeType: new` only ads posted since the last check.
- **Price drops.** A listing this watch has seen before whose price is now lower comes back as `changeType: price-drop` with `previousPrice` and `priceDrop` (euros).
- **Car and property filters that Subito itself applies.** `minPrice` / `maxPrice`, `yearFrom` / `yearTo`, `mileageFrom` / `mileageTo` (km), private or business sellers, search terms in the title only. They are sent to Subito, so the page you get is already filtered.
- **Honest about what can be read.** Subito's robots.txt does not allow page numbers, so this Actor reads the first page of each search: the 30 newest listings. When a search has more, a free row says so; in monitor mode a free row warns when more new ads appeared since the last check than fit on that page.
- **No charge when nothing could be delivered.** A search with no results, nothing in your ranges, a region, province or category Subito does not have, a page that could not be read, and a check page come back as free rows that say why.
- **Several searches in one run.** Search terms times categories times locations, plus search URLs, up to 20 searches per run.
- **Fast and light.** A production run on 2026-09-25 (all cars in Lombardia, 30 listings) took 3.6 s at 256 MB.

Unofficial. Reads the public Subito.it search result pages, the same pages a person sees without logging in, and follows Subito's robots.txt. It does not open ad detail pages, does not log in, and does not solve or bypass check pages. It returns **no seller names, no phone numbers and no user IDs**: phone numbers and e-mail addresses that sellers write into a title or description are replaced with `[phone removed]` / `[email removed]`. For businesses (dealers, agencies, shops) the shop name shown on the listing is returned.

### What you get

One row per listing. Example (a production run on 2026-09-25, `golf` in category `auto` in `milano`, 5,000-20,000 EUR, from 2015, 50,000-120,000 km):

```json
{
  "status": "ok",
  "changeType": null,
  "adId": "661986900",
  "title": "Golf 7.5",
  "price": 12750,
  "currency": "EUR",
  "previousPrice": null,
  "priceDrop": null,
  "description": "Auto in buonissime condizioni come visibile in foto,83000 km attualmente,macchina in uso, ultimo tagliando a luglio,tagliandata ogni anno con documentazione,gomme nuove,compresa quella di scorta,4 stagioni montate a luglio con garanzia 50000 km o 5 anni,ho fatto montare in Volkswagen antifurto volumetrico,vetri privacy,revisione fino a gennaio 2028,piccoli graffi ma nessuno bozza o ammaccatura.",
  "category": "Auto",
  "adType": "In vendita",
  "region": "Lombardia",
  "province": "Milano",
  "provinceCode": "MI",
  "town": "Milano",
  "listedAt": "2026-09-24T11:57:21.000Z",
  "listedLocal": "2026-09-24 13:57:21",
  "imageUrl": "https://images.sbito.it/api/v1/sbt-ads-images-pro/images/12/12aee901-bc7c-43c0-9db7-46289d9f46df?rule=gallery-desktop-2x-auto",
  "imageCount": 6,
  "isCompany": false,
  "shopName": null,
  "isPromoted": false,
  "isUrgent": false,
  "shippable": null,
  "condition": "Usato",
  "carBrand": "VOLKSWAGEN",
  "carModel": "Golf 7ª serie",
  "carVersion": "Golf 1.0 TSI 110 CV 5p. Business BlueMotion Technology",
  "year": 2017,
  "registrationDate": "12/2017",
  "mileageKm": 83000,
  "fuel": "Benzina",
  "gearbox": "Manuale",
  "powerKw": 81,
  "powerHp": 110,
  "bodyType": "Berlina",
  "emissionClass": "Euro 6",
  "sizeSqm": null,
  "rooms": null,
  "bathrooms": null,
  "floor": null,
  "energyClass": null,
  "attributes": {
    "Per neopatentati": "Sì",
    "Colore": "Nero",
    "Posti": "5",
    "Carburante": "Benzina",
    "Classe emissioni": "Euro 6",
    "Carrozzeria": "Berlina",
    "Iva esposta": "No",
    "Cambio": "Manuale",
    "Condizioni del veicolo": "Usato",
    "Auto": "VOLKSWAGEN, Golf 7ª serie, Golf 1.0 TSI 110 CV 5p. Business BlueMotion Technology",
    "Numero di porte": "4/5",
    "Km": "83000 Km",
    "Potenza": "81 kW / 110 Cv",
    "Anno di immatricolazione": "2017",
    "Immatricolazione": "12/2017",
    "Mese di immatricolazione": "Dicembre"
  },
  "url": "https://www.subito.it/auto/golf-7-5-milano-661986900.htm",
  "positionInSearch": 4,
  "listingsInSearch": 88,
  "searchQuery": "golf",
  "searchCategory": "auto",
  "searchLocation": "Milano (Lombardia)",
  "searchUrl": "https://www.subito.it/annunci-lombardia/vendita/auto/milano/?q=golf&ps=5000&pe=20000&ys=2015&ms=11&me=23",
  "watchName": null,
  "checkedAt": "2026-09-24T21:56:26.742Z"
}
```

Checked in a browser after the runs: 10 of 10 listings from two production runs (Golf in Milan with price, year and mileage ranges; flats for rent in Rome under 1,200 EUR) showed the same title, price and town on the ad page, and for the cars the same registration year and mileage.

| Column | Meaning |
|---|---|
| `status` | `ok` for a listing row. Other values are free rows that say why nothing (or not everything) was returned (below) |
| `changeType` | Monitor mode only: `first-check` (first run of this watch), `new`, `price-drop`, or `resurfaced` (only with `includeResurfaced`). Null when monitor mode is off |
| `adId`, `url` | Subito's listing number and the ad page |
| `title`, `description` | Title and the description shown in the search result (contacts removed) |
| `price`, `currency` | Price in euros (for rentals: the monthly rent). Null when the listing shows no price (nothing is made up) |
| `previousPrice`, `priceDrop` | Monitor mode, `price-drop` rows: the price at the previous check and the difference in euros |
| `category`, `adType` | Subito's category of the ad and its type as shown (In vendita, In affitto ...) |
| `region`, `province`, `provinceCode`, `town` | Where the item is (Lombardia, Milano, MI, Cinisello Balsamo) |
| `listedAt`, `listedLocal` | The date on the listing as UTC and as Italian local time. It is when the ad was posted or last bumped to the top |
| `imageUrl`, `imageCount` | First photo and number of photos |
| `isCompany`, `shopName` | The seller is a business, with the shop name shown on the listing (null for private sellers) |
| `isPromoted`, `isUrgent` | Paid visibility options shown on the listing (showcase, urgent) |
| `shippable`, `condition` | Shipping available (TuttoSubito), and the condition shown (item, vehicle or building) |
| `carBrand`, `carModel`, `carVersion`, `year`, `registrationDate`, `mileageKm`, `fuel`, `gearbox`, `powerKw`, `powerHp`, `bodyType`, `emissionClass` | Vehicles: as listed on Subito |
| `sizeSqm`, `rooms`, `bathrooms`, `floor`, `energyClass` | Property: as listed on Subito |
| `attributes` | Every other detail Subito shows on the listing, as label: value |
| `positionInSearch`, `listingsInSearch` | Position in this search and the number of results Subito reports for it |
| `searchQuery`, `searchCategory`, `searchLocation`, `searchUrl` | The search this row came from |
| `note` | Free rows only: why nothing (or not everything) was returned |
| `watchName`, `checkedAt` | The watch name you gave, and the time of the check |

#### Free rows (not charged)

| `status` | When |
|---|---|
| `no-results` | Subito has no listing for this search |
| `none-in-range` | Listings were read, but none is inside your ranges (in monitor mode: on the first check) |
| `not-found` | Subito does not have this search (HTTP 404): a region, province or category it does not know, or a province that is not in that region |
| `no-new-listings` | Monitor mode: nothing new and no price drop since the previous check |
| `more-not-returned` | Normal search: the search has more listings than the first page, which is all robots.txt allows; says how many and what to do. Monitor mode: more new listings than `maxResultsPerSearch` (a later run returns them), or, on the first check, how many listings are now the starting point |
| `more-new-than-readable` | Monitor mode: more listings appeared since the last check than fit on the first page, so some new ones may have been missed; or listings an earlier run could not return (because of `maxResultsPerSearch` or the charge limit) left the first page before they could be returned. Run more often, raise `maxResultsPerSearch` or narrow the search |
| `already-returned` | Everything inside your ranges on this search was already returned by an earlier search of the same run (overlapping searches such as a region and one of its provinces); it is not returned or charged twice |
| `not-allowed-by-robots-txt` | A search URL that Subito's robots.txt does not allow (one with a page number, `o=2`). Nothing was requested |
| `unreadable` | Subito could not be read, even after asking again from other IP addresses, or the page layout changed. Nothing is guessed and nothing is remembered |
| `blocked` | Subito showed a check page. This Actor does not solve or bypass check pages; it stops and does not run the remaining searches |
| `budget-reached` | The run hit the maximum total charge you set. In monitor mode the listings not returned are returned by the next run |
| `bad-input` | The input could not be used (for example an unknown region, province or category). The run ends as failed |

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `searchQueries` | list of strings | - | Search terms: `golf`, `iphone 15`, `panda 4x4`, `bilocale` ... Leave search terms, categories, locations and search URLs all empty to run the example: all cars (`auto`) in `lombardia` |
| `categories` | list of strings | all categories | Subito categories (list below). A category without a search term lists everything new in it |
| `locations` | list of strings | all of Italy | Regions (`lombardia`, `lazio`), provinces (`milano`, `roma`, or the code `MI`, `RM`), or `italia` |
| `adType` | `sale` or `rent` | `sale` | `rent` works with the real estate categories |
| `minPrice`, `maxPrice` | number (EUR) | - | Price range (Subito's filter) |
| `yearFrom`, `yearTo` | integer | - | Vehicles: registration year range (Subito's filter) |
| `mileageFrom`, `mileageTo` | integer (km) | - | Vehicles: mileage range. Subito filters in bands; this Actor asks for the bands that contain your numbers and keeps only listings inside the exact range |
| `sellerType` | `any`, `private`, `business` | `any` | Private sellers only, or businesses only (Subito's filter) |
| `titleOnly` | boolean | false | Match search terms in the title only |
| `searchUrls` | list of strings | - | Subito search result pages copied from the browser, for example `https://www.subito.it/annunci-lombardia/vendita/auto/milano/?q=golf` (first page only) |
| `maxResultsPerSearch` | integer 1-30 | 30 | Most listings returned for one search. In monitor mode: most new listings and price drops per search in one run (the rest come first in the next run, while they are still on the first page) |
| `onlyNew` | boolean | false | Monitor mode: return only new listings and price drops since the previous check |
| `includePriceDrops` | boolean | true | Monitor mode: return price drops too |
| `includeResurfaced` | boolean | false | Monitor mode: also return older listings (not seen by this watch) that were bumped back to the top, as `resurfaced` |
| `watchName` | string | - | Separate memories for monitor mode, for example one per client or per alert |
| `resetMonitoringState` | boolean | false | Forget what this watch has seen, so the run is a first check again |

Each search term is searched in each category and each location (up to 20 searches per run).

Categories: `auto` · `moto-e-scooter` · `veicoli-commerciali` · `caravan-e-camper` · `accessori-auto` · `accessori-moto` · `nautica` · `motori` (all vehicles) · `appartamenti` · `ville-singole-e-a-schiera` · `loft-mansarde` · `terreni-e-rustici` · `garage-e-box` · `uffici-locali-commerciali` · `camere-posti-letto` · `immobili` (all property) · `elettronica` · `informatica` · `audio-video` · `telefonia` · `fotografia` · `videogiochi` · `casa-e-persona` · `arredamento-casalinghi` · `elettrodomestici` · `giardino-fai-da-te` · `abbigliamento-accessori` · `bambini-giocattoli` · `sport-hobby` · `sport` · `biciclette` · `musica-film` · `strumenti-musicali` · `libri-riviste` · `hobby-collezionismo` · `animali` · `accessori-per-animali` · `attrezzature` · `servizi`.

Regions: `abruzzo` · `basilicata` · `calabria` · `campania` · `emilia-romagna` · `friuli-venezia-giulia` · `lazio` · `liguria` · `lombardia` · `marche` · `molise` · `piemonte` · `puglia` · `sardegna` · `sicilia` · `toscana` · `trentino-alto-adige` · `umbria` · `valle-d-aosta` · `veneto`. All 110 provinces Subito uses are accepted by name or code.

### Examples

Used VW Golf in the province of Milan, 5,000-20,000 euros, from 2015, 50,000-120,000 km:

```json
{ "searchQueries": ["golf"], "categories": ["auto"], "locations": ["milano"], "minPrice": 5000, "maxPrice": 20000, "yearFrom": 2015, "mileageFrom": 50000, "mileageTo": 120000 }
```

A dealer's feed: every new car from private sellers in Lombardia and Piemonte, and price drops, every 15 minutes (schedule this input):

```json
{ "categories": ["auto"], "locations": ["lombardia", "piemonte"], "sellerType": "private", "onlyNew": true, "watchName": "private-cars-north" }
```

Flats for rent in Rome under 1,200 euros a month:

```json
{ "categories": ["appartamenti"], "locations": ["roma"], "adType": "rent", "maxPrice": 1200 }
```

### Pricing

Pay per event:

- **Run start** - once per run that read Subito: in a normal search, before the first listing row is returned (so not charged when nothing is in your ranges); in monitor mode, when a list was read and compared, also when nothing changed - that pays for the check. Never charged when nothing could be read, the search does not exist on Subito, or robots.txt does not allow the page.
- **Listing returned** - per listing row.

Free rows are never charged. If you set a maximum total charge for a run, the run stops before it would go over it and says so; a run whose maximum has no room for the start fee plus one listing does not request anything.

### Monitor mode, step by step

1. First run: reads the newest 30 listings of each search, returns up to `maxResultsPerSearch` as `first-check`, and remembers them (with their prices) as the starting point.
2. Later runs: read the newest 30 again. A listing is `new` when its listing number is higher than every listing this watch has seen, or when it was listed after the previous check with a listing number from no more than one to two days of new ads before it (ads that appear late after Subito's review). A listing this watch has seen whose price is lower now is a `price-drop`. Older ads that were bumped back to the top (including showcase ads, which Subito moves back up regularly) are remembered but not returned as new. Listings that were not returned because of `maxResultsPerSearch` or the charge limit are returned first by the next run, as long as they are still on the first page.
3. Nothing is judged from a page that could not be read (nothing returned, remembered or charged); the next run checks it again.

Within one run, a listing found by two overlapping searches is returned once.

Keep one schedule per search and watch name. Two overlapping runs of the same watch can both return the same new listing (the memory is a key-value store without transactions).

### Limits

- Subito's robots.txt does not allow page numbers, so only the first page (30 newest listings) of each search is read. Busy searches (all cars in Italy get new ads every few minutes) move faster than that: narrow them with a province, a category, a price or year range, and schedule a watch often enough - or split one big search into several smaller ones in the same run.
- Only the fields shown on the search result list are returned. Ad detail pages, seller profiles and phone numbers are not read.
- Price drops are seen for listings that are still on the first page of the search.
- The date on the listing is when the ad was posted or last bumped to the top; Subito does not show the original posting date on the list.
- If Subito refuses datacenter IP addresses, pages are read over residential IP addresses: up to 20 per run, and up to 3 per monitor run (a monitor check that finds nothing new only pays the start fee). Searches beyond that come back as free `unreadable` rows.

### Support

Questions, a field you need, or a search that does not work: open an issue on the Issues tab of this Actor.

# Actor input Schema

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

What you would type into the Subito search box, for example golf, iphone 15, panda 4x4, bilocale. Each search term is searched in each category and location. Leave Search terms, Categories, Locations and Search URLs all empty to run the example search: all cars (auto) in Lombardia.

## `categories` (type: `array`):

Optional. Subito categories, for example auto, moto-e-scooter, veicoli-commerciali, appartamenti, telefonia, informatica, biciclette. Empty = all categories. A category alone (without a search term) lists everything new in it. The README lists all categories.

## `locations` (type: `array`):

Optional. Italian regions (lombardia, lazio, sicilia), provinces (milano, roma, torino, or the code MI, RM, TO) or italia for the whole country. Empty = all of Italy. An unknown place is refused before anything is requested.

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

sale (default) = listings for sale. rent = rentals; works with the real estate categories (appartamenti, ville-singole-e-a-schiera, loft-mansarde, camere-posti-letto, garage-e-box, uffici-locali-commerciali, terreni-e-rustici, immobili).

## `minPrice` (type: `number`):

Optional. Only listings at or above this price (Subito's own price filter). For rentals this is the monthly rent.

## `maxPrice` (type: `number`):

Optional. Only listings at or below this price (Subito's own price filter).

## `yearFrom` (type: `integer`):

Optional. Vehicles first registered in this year or later (Subito's own filter). Listings without a year are left out when it is set.

## `yearTo` (type: `integer`):

Optional. Vehicles first registered in this year or earlier.

## `mileageFrom` (type: `integer`):

Optional. Minimum mileage in km. Subito filters by mileage bands, so this Actor asks for the band that contains your number and then keeps only listings at or above the exact value.

## `mileageTo` (type: `integer`):

Optional. Maximum mileage in km (asked as a Subito band, then cut at the exact value).

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

Any (default), private sellers only, or businesses (dealers, shops) only. Subito's own filter.

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

On: Subito matches the search terms only in the listing title (Ricerca solo nel titolo), not in the description. Useful for short terms such as golf or 500.

## `searchUrls` (type: `array`):

Optional. Subito search result pages copied from your browser, with any filters you set there (brand, model, fuel ...), for example https://www.subito.it/annunci-lombardia/vendita/auto/milano/?q=golf. Paste the first page: page numbers (o=2) are not allowed by Subito's robots.txt and come back as a free row.

## `maxResultsPerSearch` (type: `integer`):

Most listings returned for one search. Subito's robots.txt allows only the first page of a search (the 30 newest listings), so 30 is the maximum and the default. In monitor mode it limits the new listings and price drops returned per search in one run; the rest come first in the next run, while they are still among the 30 newest.

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

On: every run reads the newest 30 listings of each search and returns only listings that are new since the previous check (changeType new) and listings whose price went down (changeType price-drop, with previousPrice). Older listings that were bumped back to the top are not sold as new. The first run returns the current listings (changeType first-check) and remembers them as the starting point. Each run that reads the list is charged the run start fee even when nothing changed; runs where nothing changed return a free row saying so. Schedule it often (for example every 15 minutes) on busy searches: only the first page can be read.

## `includePriceDrops` (type: `boolean`):

On (default): in monitor mode, also return listings whose price is lower than at the previous check. Off: only new listings.

## `includeResurfaced` (type: `boolean`):

Off (default): an older listing that was bumped back to the top of the list, which this watch had not seen before, is not returned. On: return it with changeType resurfaced instead of new.

## `watchName` (type: `string`):

Optional. Keeps separate memories for monitor mode, for example one per client (letters, digits, dot, dash, underscore; up to 40). Runs with the same watch name and the same search share what has already been returned.

## `resetMonitoringState` (type: `boolean`):

On: forget what this watch has seen for these searches before running, so this run is a first check again.

## Actor input object example

```json
{
  "searchQueries": [
    "golf"
  ],
  "categories": [
    "auto"
  ],
  "locations": [
    "lombardia"
  ],
  "adType": "sale",
  "sellerType": "any",
  "titleOnly": false,
  "onlyNew": false,
  "includePriceDrops": true,
  "includeResurfaced": false,
  "resetMonitoringState": false
}
```

# Actor output Schema

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

One row per Subito.it listing: ad ID, title, price, description, category, region, province and town, date listed, photo, business seller flag and shop name, car details (brand, model, year, mileage, fuel, gearbox, power) and property details (size, rooms, floor, energy class), link, and its position in the search. Monitor mode marks rows first-check, new, price-drop (with the previous price) or resurfaced. A search with no listings, nothing new, an unknown region or category, a page robots.txt does not allow, a refused request or a run that hit its maximum charge comes back as a free row that says why.

# 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": [
        "golf"
    ],
    "categories": [
        "auto"
    ],
    "locations": [
        "lombardia"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("neverempty/subito-it-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 = {
    "searchQueries": ["golf"],
    "categories": ["auto"],
    "locations": ["lombardia"],
}

# Run the Actor and wait for it to finish
run = client.actor("neverempty/subito-it-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 '{
  "searchQueries": [
    "golf"
  ],
  "categories": [
    "auto"
  ],
  "locations": [
    "lombardia"
  ]
}' |
apify call neverempty/subito-it-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,neverempty/subito-it-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/1ycfZVH1XzxOx0Rta/builds/euIch8FZwbsTO2Ukc/openapi.json