# PagineGialle Scraper $1.5/1K💰 | Italy B2B Leads | Reviews (`ahmed_jasarevic/paginegialle-scraper`) Actor

Collect Italian business leads from PagineGialle.it — Italy's Yellow Pages. Get phones, emails, websites, addresses, opening hours and customer reviews for B2B prospecting, CRM enrichment, local SEO and Italian market research.

- **URL**: https://apify.com/ahmed\_jasarevic/paginegialle-scraper.md
- **Developed by:** [Ahmed Jasarevic](https://apify.com/ahmed_jasarevic) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 1,000 business 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/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

## PagineGialle Scraper — Italian Business Leads & Reviews

Collect **Italian business leads from PagineGialle.it** (Italy's Yellow Pages) — business name, category, address, phone numbers, email, website, opening hours, GPS, and customer reviews — **without a proxy and without an official API key**. Built for B2B lead generation, CRM enrichment, local SEO, and Italian market research.

### Main Use Cases

- **B2B lead generation in Italy** — build prospect lists for any business sector and city
- **CRM enrichment** — append phones, emails, websites, hours, and geo to existing records
- **Local SEO research** — audit business listings and competitor presence across Italian regions
- **Reviews & reputation monitoring** — pull customer reviews (with business replies) per listing
- **Sales prospecting** — keyword-category search across cities, provinces, and regions
- **Market mapping** — map the competitive landscape of any Italian industry

### How It Works

The actor talks to **Italiaonline's mobile search API** (`ws.paginegialle.it/search`) — the same backend that powers PagineGialle's mobile app — over plain HTTP. **No proxy, no browser, no WAF challenge** for listing extraction: each results page returns ~26 businesses with contact details, GPS, category, and full weekly hours directly in the list, so there are **no per-listing follow-up requests**.

Business records go to the **Business Listings** dataset. Optionally, customer reviews are fetched from PagineGialle's comments API — plain HTTP first, with a lazy headless-Chrome solve of the AWS WAF challenge only when a review fetch is actually blocked (the WAF token is cached and reused across runs).

The actor writes to **two separate datasets**:

| Dataset | Contains | Record `type` |
|---|---|---|
| **Business Listings** (default) | One item per paginegialle.it listing | `business` |
| **Reviews** (`reviews` alias) | One item per business review, joined via `cdIdSede` | `review` |

Both datasets are exposed in the **Storage/Output** tab of each run and can be exported/downloaded independently.

### Build Italian B2B Lead Lists Without an Official PagineGialle API

PagineGialle does not publish a public developer API for third-party data access. This actor reads the same structured backend the PagineGialle mobile app uses, so you get complete business data — including published email, all phone numbers, and full weekly hours — without an API contract, without visiting each listing page, and without configuring proxies.

### Collect Italian Business Contacts for CRM Enrichment & Local SEO

Each business record includes primary and secondary phone numbers (with type flags like `fisso` / `cellulare` and an `isPayNumber` marker), published email, website, GPS coordinates, distance from the search point, opening status and weekly hours, feature flags (email/web/video/reservation/ecommerce), and the PagineGialle listing URL. Perfect input for lead scoring, deduplication, and downstream CRM workflows.

### Monitor Customer Reviews for Italian Businesses

Enable `includeReviews: true` to fetch customer reviews per business: rating (1–5) and label, full review text, reviewer name, date, publisher metadata (e.g. Google, Tripadvisor), and business replies. Review records reference their business through `cdIdSede` — the same join key your own database can use.

### Input

| Field | Type | Required | Default | Notes |
|---|---|---|---|---|
| `mode` | string | No | auto | `search` (keyword) | `direct` (listing URLs) | `both`. Auto: `direct` when only `urls`, `both` when both, else `search`. |
| `what` | string | For search | — | Business type or keyword, e.g. `ristoranti`, `farmacia`, `avvocati`. |
| `where` | string | For search | `Roma` | City, province, or region, e.g. `Milano`, `RM`, `Lazio`. Also the fallback scope for URLs without a city hint. |
| `sortBy` | string | No | `relevance` | `relevance` | `city` | `name` | `popularity` (search mode). |
| `maxItems` | integer | No | 100 | Max listings from keyword search (**0 = unlimited**). Direct URLs bypass this cap. |
| `urls` | array | For direct | — | PagineGialle listing URLs to resolve as exact businesses — each URL produces one result. |
| `includeReviews` | boolean | No | false | Fetch reviews for every business (Reviews dataset). |
| `reviewsSort` | string | No | `date_desc` | `date_desc` | `rating_desc` | `rating_asc`. |
| `maxReviewsPerBusiness` | integer | No | 20 | Cap on reviews kept per business. |

### Output

**Business Listings** dataset fields:

| Field | Description |
|---|---|
| `businessName` / `category` / `categoryCode` | Business identity and PagineGialle category code |
| `address` / `city` / `province` / `postalCode` / `country` | Location breakdown |
| `phone` / `phones` | Primary phone / all phones with type (`fisso`, `cellulare`, …) and `isPayNumber` flag |
| `email` / `website` | Published email and website (where available) |
| `latitude` / `longitude` | GPS coordinates |
| `distance` / `geolevel` | Distance and geo precision from the search location |
| `listingUrl` | URL of the listing on paginegialle.it |
| `description` | Business description (`abstract`) |
| `openingStatus` / `closingTime` / `openingHours` | Current open/closed state and weekly hours |
| `flags` | Feature flags (email, web, video, reservation, ecommerce, …) |
| `cdIdSede` | PagineGialle location ID — join key to the reviews dataset |
| `scrapedAt` / `sourceUrl` | Timestamp and API call the listing came from |

**Reviews** dataset fields (with `includeReviews: true`): `reviewId`, `cdIdSede`, `businessName`, `sourceUrl`, `reviewSourceUrl`, `rating` (1–5), `ratingLabel`, `text`, `userName`, `date`, `answers` (business replies), `thumbsUp`, `publisher`, `deviceOrigin`.

### Example Input

Keyword search — restaurants in Rome:

```json
{
  "mode": "search",
  "what": "ristoranti",
  "where": "Roma",
  "sortBy": "popularity",
  "maxItems": 500
}
```

Direct listing URLs + reviews:

```json
{
  "mode": "direct",
  "urls": [
    "https://www.paginegialle.it/ristorante-la-favola-rm",
    "https://www.paginegialle.it/checchinodal1887"
  ],
  "includeReviews": true,
  "maxReviewsPerBusiness": 20
}
```

Both at once:

```json
{
  "mode": "both",
  "what": "ristoranti",
  "where": "Roma",
  "maxItems": 100,
  "urls": ["https://www.paginegialle.it/checchinodal1887"]
}
```

### Running the Two Parts Independently

- **Search-only run** (`mode: "search"`) → populates **Business Listings** only.
- **Direct run** (`mode: "direct"`, `includeReviews: false`) → populates **Business Listings** only.
- **Reviews run** (`mode: "direct"`, `includeReviews: true`) → populates both datasets.

To automate each pipeline independently, save two Apify **scheduled tasks**: one search-only for lead collection, one direct+reviews for review monitoring. Trigger either via `POST /v2/acts/{actorId}/runs` with the matching input.

### Integrations & Automation

- **Apify API** — trigger runs from any stack; run search-only, direct, or reviews-only pipelines separately
- **Scheduling** — weekly lead refreshes, daily review monitoring
- **Webhooks & integrations** — Zapier, Make, CRM imports (HubSpot, Salesforce) via the Apify platform
- **Export** — JSON, CSV, Excel, HTML, XML per dataset

### Cost Estimation

Pay-per-event: **$0.0015 per business** (primary event) + **$0.0005 per review** + **$0.00005** start fee. Listing extraction is plain HTTP and memory-light (~256 MB), so a 100-business run costs about **$0.15** plus compute. Enabling reviews raises memory (~1 GB) when headless Chrome is needed and adds the per-review event. Free-tier accounts are capped at 10 items per run.

### Notes & Limitations

- Some listings (non-paying businesses) have no phone/email/website — those fields are `null`/empty.
- **VAT/tax IDs are not exposed** by this API.
- Listings page at ~26 results per page; `max_results` in the response reports the estimated total for a query.
- The listing API is HTTP-only (HTTPS is not served by the host).
- Reviews come from PagineGialle's comments API behind AWS WAF — solved lazily with headless Chrome only when blocked; the token is cached across runs. Some businesses legitimately have no reviews.

### Related Actors

- [Google Maps Scraper](https://apify.com/compass/google-places-scraper) — local business data, contacts, and reviews at global scale
- [Yellow Pages US Scraper](https://apify.com/trudax/yellow-pages-us-scraper) — the US yellow pages counterpart
- [Italy Registro Imprese & VAT Lookup](https://apify.com/jungle_synthesizer/italy-registroimprese-bilanci-scraper) — official Italian company data, Partita IVA, and PEC
- [PagineGialle Scraper — Italian Business Leads](https://apify.com/emastra/pagine-gialle-scraper) — PagineGialle.it listings with lead-quality flags
- [PagineGialle Italy Business Directory Scraper](https://apify.com/automation-lab/paginegialle-scraper) — Italian businesses by category and city

### FAQ

#### Why use this actor instead of the official PagineGialle API?

PagineGialle doesn't expose a public developer API. This actor uses the same mobile-search backend (`ws.paginegialle.it/search`) the PagineGialle app uses — no WAF challenge, no proxy needed, and complete contact/hours data at the list level without visiting each listing page.

#### What are alternatives to PagineGialle data for Italy?

For official company records, [Registro Imprese](https://apify.com/jungle_synthesizer/italy-registroimprese-bilanci-scraper) (Camera di Commercio) is the authoritative source for VAT/Partita IVA, legal form, and PEC. For local-business data beyond directories, a [Google Maps scraper](https://apify.com/compass/google-places-scraper) covers businesses, contacts, and reviews.

#### Is scraping PagineGialle GDPR compliant?

The actor only reads publicly published business listings — business-published contact information. As the user, you are responsible for complying with the GDPR and Italian data-protection law (D.Lgs. 196/2003) when storing or processing personal data, e.g. not using emails or phones for unsolicited commercial outreach without a lawful basis.

#### How much does PagineGialle scraping cost?

$0.0015 per business + $0.0005 per review + a $0.00005 start fee. Reviews are charged only when you enable `includeReviews`.

#### Why is no proxy required?

The actor calls the mobile search API (`ws.paginegialle.it`, HTTP-only) which is served without the AWS WAF protection that challenges the public website. Reviews sit behind AWS WAF — they are fetched over plain HTTP first, and headless Chrome solves the challenge lazily only when actually blocked.

#### Do all listings have emails and phones?

No. Non-paying businesses may publish no phone, email, or website — those fields are `null`/empty. VAT/tax IDs are not exposed by this API. Some businesses legitimately have no reviews.

### For AI Agents & LLM Apps

This actor is callable via the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp) and the Apify REST API.

- **Purpose:** returns structured Italian business listings — name, category, address, phones, email, website, hours, GPS — from PagineGialle.it, plus optional customer reviews.
- **Minimal working input:**

```json
{ "mode": "search", "what": "ristoranti", "where": "Roma", "maxItems": 20 }
```

- **Variant modes:**
  - Direct-listing enrichment: `{ "mode": "direct", "urls": ["https://www.paginegialle.it/checchinodal1887"] }`
  - Reviews: add `"includeReviews": true` (writes to the `reviews` dataset).
- **Output fields (business):** `type`, `businessName`, `category`, `categoryCode`, `address`, `city`, `province`, `postalCode`, `country`, `phone`, `phones`, `email`, `website`, `latitude`, `longitude`, `distance`, `geolevel`, `listingUrl`, `description`, `openingStatus`, `closingTime`, `openingHours`, `logo`, `imageUrl`, `flags`, `cdIdSede`, `userDetail`, `urldetailMobile`, `scrapedAt`, `sourceUrl`.
  **Output fields (review):** `type`, `reviewId`, `cdIdSede`, `businessName`, `sourceUrl`, `reviewSourceUrl`, `rating`, `ratingLabel`, `text`, `userName`, `date`, `answers`, `thumbsUp`, `publisher`, `deviceOrigin`.
- **Behaviors an agent should know:**
  - `mode` is auto-detected: only `urls` → `direct`; both `what`/`where` and `urls` → `both`; otherwise `search`.
  - `what` and `where` are required for search mode; `urls` is required for direct mode. A run with neither fails.
  - `maxItems` defaults to 100; **`maxItems: 0` means unlimited** — avoid it unless the caller wants an unbounded (and unboundedly billed) run.
  - `includeReviews: true` adds per-review charges and writes to the `reviews` dataset, not the default one.
  - The run that first solves the AWS WAF challenge needs ~1 GB (headless Chrome); listing-only runs stay at ~256 MB.
- **Billing:** pay-per-event — **$0.0015 per business** + **$0.0005 per review** + **$0.00005** run start.

### Legal & Compliance Disclaimer

This actor is an independent tool and is **not affiliated with, endorsed by, or sponsored by** Italiaonline S.p.A. or PagineGialle.it.

The actor accesses **publicly published business listings** through the same mobile search backend PagineGialle's app uses. It does not bypass logins; when review fetches hit an AWS WAF JavaScript challenge, it is solved like a standard browser would solve it and the token is cached per IP. Users are responsible for complying with PagineGialle's Terms of Service, the GDPR, and Italian data-protection law (D.Lgs. 196/2003). Contact data returned by this actor should not be used for unsolicited commercial outreach without a lawful basis.

### SEO Keywords

paginegialle scraper, paginegialle api, italian business directory data, italian yellow pages, b2b lead generation italy, italian business leads, italy business contact database, italian company directory, local seo italy, italian business email list, italian business phone numbers, paginegialle alternative, italian business reviews, registro imprese alternative, italian business data, crm enrichment italy, sales prospecting italy, aziende italiane contatti, elenco imprese italia, ristoranti roma, avvocati milano, impresa edile

# Actor input Schema

## `mode` (type: `string`):

Search only (keyword), direct listings only (URLs), or both at once. Defaults to auto: 'direct' if only urls provided, 'both' if both, 'search' otherwise.

## `what` (type: `string`):

Required for 'search' or 'both' mode. A PagineGialle category or keyword, e.g. "ristoranti", "farmacia", "avvocati".

## `where` (type: `string`):

City, province or region (for keyword search). Used as fallback when a direct URL doesn't carry a city hint. Default: Roma.

## `sortBy` (type: `string`):

How search results are ordered.

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

Maximum number of business listings from keyword search. Set to 0 for unlimited. Direct URLs are always resolved regardless of this cap.

## `urls` (type: `array`):

PagineGialle listing URLs to resolve as exact businesses (each becomes one result). Requires mode 'direct' or 'both'. Example: https://www.paginegialle.it/ristorante-la-favola-rm

## `includeReviews` (type: `boolean`):

Fetch each business's reviews (rating, text, user, date, business replies) from paginegialle.it. Reviews are fetched over plain HTTP first — only if blocked by AWS WAF does a headless-Chrome solve fire lazily. ~1 GB RAM when a solve is needed.

## `reviewsSort` (type: `string`):

Order of fetched reviews.

## `maxReviewsPerBusiness` (type: `integer`):

Maximum number of reviews to keep for each business.

## Actor input object example

```json
{
  "what": "ristoranti",
  "where": "Roma",
  "sortBy": "relevance",
  "maxItems": 100,
  "urls": [
    "https://www.paginegialle.it/ristorante-la-favola-rm",
    "https://www.paginegialle.it/checchinodal1887"
  ],
  "includeReviews": false,
  "reviewsSort": "date_desc",
  "maxReviewsPerBusiness": 20
}
```

# Actor output Schema

## `businessListings` (type: `string`):

Business listings dataset. One item per PagineGialle listing.

## `reviews` (type: `string`):

Reviews dataset. One item per business review (only when includeReviews is on).

# 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 = {
    "what": "ristoranti",
    "where": "Roma",
    "urls": [
        "https://www.paginegialle.it/ristorante-la-favola-rm",
        "https://www.paginegialle.it/checchinodal1887"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("ahmed_jasarevic/paginegialle-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 = {
    "what": "ristoranti",
    "where": "Roma",
    "urls": [
        "https://www.paginegialle.it/ristorante-la-favola-rm",
        "https://www.paginegialle.it/checchinodal1887",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("ahmed_jasarevic/paginegialle-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 '{
  "what": "ristoranti",
  "where": "Roma",
  "urls": [
    "https://www.paginegialle.it/ristorante-la-favola-rm",
    "https://www.paginegialle.it/checchinodal1887"
  ]
}' |
apify call ahmed_jasarevic/paginegialle-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,ahmed_jasarevic/paginegialle-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/72AQeA5fbihq4zz7i/builds/kzmuRGzyahKTPflhZ/openapi.json