# PagineGialle Scraper — Italian Business Directory (`studio-amba/paginegialle-it-scraper`) Actor

Scrape business leads from PagineGialle.it, Italy's Pagine Gialle yellow pages. Search by category and city to extract company name, category, full address, city, province, postal code and phone number. Phone appears on nearly every listing. Website is present only on a small share of paid listings.

- **URL**: https://apify.com/studio-amba/paginegialle-it-scraper.md
- **Developed by:** [Studio Amba](https://apify.com/studio-amba) (community)
- **Categories:** Business, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $12.00 / 1,000 result scrapeds

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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## PagineGialle Scraper — Italian Business Directory

Extract business listings from **PagineGialle.it**, Italy's national yellow pages.
Search any keyword and city and get clean, structured JSON: business name, category,
full address, and phone numbers. Phone numbers are present on virtually every listing,
which makes this a fast way to build Italian local-business and lead lists.

No login, no manual cookie handling, no captcha solving on your side — the actor
handles the site's bot protection for you.

### What this actor does

You give it a search term (in Italian) and a city. It walks the PagineGialle search
results, page by page, and returns one structured record per business. Under the hood it
solves the site's AWS WAF bot challenge once with a headless browser, then reuses that
session to fetch the remaining result pages over plain HTTP — so it stays fast and cheap
while still getting past the protection that blocks naive scrapers.

### Why use it

- **Lead generation.** Build call lists of Italian businesses by trade and city
  (restaurants, plumbers, lawyers, dentists, hotels, and anything else in the directory).
- **Market research.** Map how many providers of a given service operate in a city or
  province, with their addresses.
- **Local SEO / data enrichment.** Match and enrich your own records with phone numbers
  and addresses from Italy's most-used business directory.

### How to scrape PagineGialle data

1. Set **Search Query** to what you are looking for, in Italian — for example
   `ristorante`, `idraulico`, `avvocato`, `dentista`, or a business name.
2. Set **Location** to an Italian city or town, for example `Roma`, `Milano`,
   `Napoli`, or `Torino`.
3. Set **Max Results** to how many listings you want (each result page holds about 25).
4. Keep the **Proxy Configuration** on Italian residential proxies (RESIDENTIAL group,
   country IT). This is required to pass the site's bot protection.
5. Run the actor. Results stream into the dataset and can be exported as JSON, CSV,
   Excel, or fed into another tool via the API.

The actor paginates automatically and stops when it reaches your Max Results or runs out
of listings for the search. Duplicate listings across pages are removed automatically.

### Input

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `searchQuery` | string | no (default `ristorante`) | What to search for, in Italian: a category, activity, or business name. |
| `location` | string | no (default `Roma`) | Italian city or town to search in. |
| `maxResults` | integer | no (default 100) | Maximum number of listings to collect across all pages. |
| `proxyConfiguration` | object | recommended | Apify proxy settings. Use RESIDENTIAL, country IT. |

#### Example input

```json
{
  "searchQuery": "avvocato",
  "location": "Milano",
  "maxResults": 100,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"],
    "apifyProxyCountry": "IT"
  }
}
````

### Output

Each item is a flat JSON object with these fields:

| Field | Type | Coverage | Description |
|-------|------|----------|-------------|
| `businessName` | string | ~100% | Business name as listed. |
| `category` | string | ~100% | Primary activity/category (Italian). |
| `address` | string | ~100% | Street address line. |
| `city` | string | ~100% | City or town (comune). |
| `province` | string | ~100% | Two-letter Italian province code (e.g. `RM`, `MI`). |
| `postalCode` | string | ~100% | Italian postal code (CAP), five digits. |
| `phone` | string | ~100% | Primary phone number as published. |
| `additionalPhones` | array | as available | Any further phone numbers for the business. |
| `website` | string | ~5–15% | External website, when the business publishes one (paid feature). |
| `url` | string | ~100% | PagineGialle profile URL. |
| `scrapedAt` | string | 100% | ISO 8601 timestamp of the scrape. |

#### A note on website and email

PagineGialle only shows an external **website** link for a minority of businesses (it is
a paid listing feature), so expect website coverage in the single-to-low-double-digit
percent range. **Email is not published** on the directory and this actor does not return
it. What the directory does expose on almost every listing — and what this actor is built
around — is the **phone number and address**.

#### Example output

```json
{
  "businessName": "Ristorante Tana della Volpe",
  "category": "Ristoranti",
  "address": "Via Adeodato Ressi, 82",
  "city": "Roma",
  "province": "RM",
  "postalCode": "00148",
  "phone": "06 6531862",
  "additionalPhones": [
    "06 60200039",
    "06 6550256"
  ],
  "website": "https://www.ristorantetanadellavolpe.com",
  "url": "https://www.paginegialle.it/ristorantetanadellavolpe",
  "scrapedAt": "2026-07-12T21:51:04.005Z"
}
```

### Tips for good results

- **Search in Italian.** The directory is an Italian-language site. Use Italian trade
  words (`idraulico` not `plumber`, `avvocato` not `lawyer`).
- **One city per run for depth.** A single city query returns a bounded number of pages.
  To cover a whole region, run several city queries (or several trades) and combine the
  datasets.
- **Broad terms return more.** `ristorante` returns far more than a niche sub-category.
- **Phone-first lead lists.** Because phone and address are near-complete and website is
  sparse, this actor is best used to build phone/address lead lists, not email lists.

### Limitations and known issues

- **Website coverage is low** (paid listing feature) and **email is not available** — see
  the note above.
- Very large single-city queries are bounded by how many pages the site serves for that
  search. Segment by city or trade to go wider.
- The site is protected by AWS WAF Bot Control. The actor solves the challenge with a
  browser and replays the session over HTTP; on the rare occasion the session is
  re-challenged mid-run it re-solves automatically. Italian residential proxies are
  required for this to work reliably.

### How it works (technical)

1. A headless Chromium session loads the first results page through an Italian residential
   proxy and passes the AWS WAF JavaScript challenge.
2. The resulting session cookies and browser-rendered first page are captured.
3. Remaining pages are fetched over plain HTTP (`got-scraping`) reusing the same session
   and proxy IP — fast and inexpensive.
4. Listings are parsed from the server-rendered HTML; phone numbers come straight from the
   listing markup (no per-listing "reveal" request), so no slow detail-page crawl is
   needed.
5. Results are de-duplicated by profile URL before being written to the dataset.

### Related scrapers

Building EU business and lead-generation datasets? Pair this with our other directory and
registry scrapers:

- **Panoramafirm Scraper** — Polish business directory (phone + email).
- **Firmy.cz Scraper** — Czech business directory (Seznam).
- **Allabolag Scraper** — Swedish company directory with revenue and CEO data.
- **Local.ch Scraper** — Swiss business directory.
- **Ares Scraper** — Czech company register (official registry data).
- **Companies House Scraper** — UK company register.

Search the Apify Store for `directory`, `business`, or `lead generation` to find the full
set.

### Legal

Use this actor responsibly and in line with PagineGialle's terms and applicable law
(including GDPR when handling personal data). You are responsible for how you use the data
you collect. This actor extracts only publicly displayed business listing information.

# Actor input Schema

## `searchQuery` (type: `string`):

What to search for, in Italian — a category or activity such as 'ristorante', 'idraulico', 'avvocato', 'dentista', or a business name. Leave empty to use the default 'ristorante'.

## `location` (type: `string`):

Italian city or town to search in, e.g. 'Roma', 'Milano', 'Napoli', 'Torino'. Leave empty to use the default 'Roma'.

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

Maximum number of business listings to scrape across all result pages. Each page holds roughly 22 listings.

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

Proxy settings. PagineGialle is behind AWS WAF Bot Control, so Italian residential proxies are required. Keep the RESIDENTIAL group with country IT.

## Actor input object example

```json
{
  "searchQuery": "ristorante",
  "location": "Roma",
  "maxResults": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "IT"
  }
}
```

# 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 = {
    "searchQuery": "ristorante",
    "location": "Roma",
    "maxResults": 20,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "IT"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("studio-amba/paginegialle-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 = {
    "searchQuery": "ristorante",
    "location": "Roma",
    "maxResults": 20,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "IT",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("studio-amba/paginegialle-it-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 '{
  "searchQuery": "ristorante",
  "location": "Roma",
  "maxResults": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "IT"
  }
}' |
apify call studio-amba/paginegialle-it-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "PagineGialle Scraper — Italian Business Directory",
        "description": "Scrape business leads from PagineGialle.it, Italy's Pagine Gialle yellow pages. Search by category and city to extract company name, category, full address, city, province, postal code and phone number. Phone appears on nearly every listing. Website is present only on a small share of paid listings.",
        "version": "0.1",
        "x-build-id": "a4bLPVET97Zutz6uV"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/studio-amba~paginegialle-it-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-studio-amba-paginegialle-it-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/studio-amba~paginegialle-it-scraper/runs": {
            "post": {
                "operationId": "runs-sync-studio-amba-paginegialle-it-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/studio-amba~paginegialle-it-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-studio-amba-paginegialle-it-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": {
                    "searchQuery": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "What to search for, in Italian — a category or activity such as 'ristorante', 'idraulico', 'avvocato', 'dentista', or a business name. Leave empty to use the default 'ristorante'."
                    },
                    "location": {
                        "title": "Location (city)",
                        "type": "string",
                        "description": "Italian city or town to search in, e.g. 'Roma', 'Milano', 'Napoli', 'Torino'. Leave empty to use the default 'Roma'."
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of business listings to scrape across all result pages. Each page holds roughly 22 listings.",
                        "default": 100
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings. PagineGialle is behind AWS WAF Bot Control, so Italian residential proxies are required. Keep the RESIDENTIAL group with country IT."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
