# PagineGialle Italy Business Directory Scraper (`automation-lab/paginegialle-scraper`) Actor

Scrape Italian business listings from PagineGialle.it — the Italian Yellow Pages. Search by category and city to collect leads with phone numbers, addresses, and websites.

- **URL**: https://apify.com/automation-lab/paginegialle-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/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.md):

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

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

Extract structured business data from [PagineGialle.it](https://www.paginegialle.it) — Italy's leading Yellow Pages directory. Scrape restaurants, lawyers, plumbers, doctors, and any business category across Italian cities to build lead lists, power local SEO research, and fuel B2B sales campaigns.

### What does it do?

This actor searches PagineGialle.it by category and location (city or postcode), and extracts business listings with contact details. For each business found, it returns:

- **Business name**
- **Phone number**
- **Full address** (street, city, province, postal code)
- **Website URL**
- **Category / service type**
- **Profile page URL**

No coding required. Provide search queries in plain Italian ("ristoranti" + "Roma"), run the actor, and download structured data in JSON, CSV, or Excel format.

### Who is it for?

- 🧑‍💼 **Sales teams** building targeted lead lists of Italian businesses by industry and city
- 📍 **Local SEO agencies** auditing business listings and competitor presence in Italian markets
- 📊 **Market researchers** mapping the competitive landscape across Italian regions
- 🏢 **B2B marketers** prospecting for restaurants, hotels, lawyers, plumbers, and other professionals
- 🛒 **E-commerce operators** finding wholesale suppliers, distributors, and trade partners in Italy
- 🗺️ **Business directory aggregators** keeping their own Italian business databases up to date

### Why use this scraper?

PagineGialle.it is the authoritative Italian business directory with millions of verified listings. Unlike manual searching:

- ✅ Collect 25+ listings per query in seconds
- ✅ Search multiple cities and categories in a single run
- ✅ Get structured, clean data ready for CRM import
- ✅ Extract phone numbers and addresses in standardized format
- ✅ Run without signing in or maintaining cookies

### What data does it extract?

| Field | Description | Example |
|-------|-------------|---------|
| `name` | Business name | "Ristorante Bella Italia" |
| `phone` | Primary phone number | "06 12345678" |
| `address` | Street address | "Via del Corso, 45" |
| `city` | City name | "Roma" |
| `province` | Province code (2-3 letters) | "RM" |
| `postalCode` | Italian postal code (CAP) | "00186" |
| `website` | Business website URL | "https://example.it" |
| `category` | Service/feature category | "Ambiente climatizzato" |
| `description` | Business description snippet | "Cucina romana tradizionale..." |
| `profileUrl` | PagineGialle profile URL | "https://www.paginegialle.it/..." |
| `searchQuery` | Category used in the search | "ristoranti" |
| `searchLocation` | Location used in the search | "Roma" |

### How much does it cost to scrape Italian business listings from PagineGialle?

This actor uses **pay-per-result** pricing. You only pay for the business listings you actually collect.

| Plan | Price per result |
|------|-----------------|
| 🆓 Free tier | First results free |
| 🥉 Bronze | $0.003 per result |
| 🥈 Silver | ~$0.0023 per result |
| 🥇 Gold | ~$0.0018 per result |
| 💎 Platinum+ | ~$0.0012–$0.0009 per result |

**Example costs:**
- 100 Italian restaurants in Milan → ~$0.30
- 500 lawyers across 5 Italian cities → ~$1.50
- 2,000 plumbers nationwide → ~$6.00

All runs include a small one-time start cost ($0.005) plus per-result charges. For Apify free plan users, the free quota typically covers 100–200 results per month.

### How to use

#### Step 1: Set up search queries

Under **🔍 Search**, add one or more queries. Each query has:
- **Category (cosa)** — the type of business in Italian (e.g. `ristoranti`, `avvocati`, `idraulici`, `dentisti`)
- **City / location (dove)** — the Italian city or location (e.g. `Roma`, `Milano`, `Napoli`, `Torino`)

**Example queries:**
```json
[
  {"what": "ristoranti", "where": "Roma"},
  {"what": "avvocati", "where": "Milano"},
  {"what": "idraulici", "where": "Napoli"}
]
````

#### Step 2: Set limits

Under **⚙️ Limits**, set **Max results per query**. Each search URL returns up to 25 results. Use multiple queries (different postcodes) to collect larger datasets.

#### Step 3: Run and export

Click **Run** and wait for results. Export data as **JSON**, **CSV**, or **Excel** from the dataset tab.

#### Using Start URLs instead

Advanced users can paste direct PagineGialle.it search URLs under **🔗 Start URLs**:

```
https://www.paginegialle.it/ricerca/ristoranti/roma
https://www.paginegialle.it/ricerca/avvocati/00100-roma
```

This gives you full control over the search URL, including postcode-level targeting (e.g. `00100-roma` vs `00187-roma` for different districts).

### Input parameters

| Parameter | Type | Description | Default |
|-----------|------|-------------|---------|
| `searchQueries` | Array | List of {what, where} search objects | `[{what: "ristoranti", where: "Roma"}]` |
| `startUrls` | Array | Direct PagineGialle.it search URLs | `[]` |
| `maxResults` | Integer | Max results to collect (0 = unlimited) | `50` |
| `proxyConfiguration` | Object | Proxy settings (Apify Residential recommended) | `{useApifyProxy: true}` |
| `maxRequestRetries` | Integer | Retry attempts for failed requests | `3` |

### Output example

```json
{
  "name": "Ristorante Alla Rampa",
  "category": null,
  "address": "Piazza Mignanelli, 18",
  "city": "Roma",
  "province": "RM",
  "postalCode": "00187",
  "phone": "06 6782621",
  "website": "https://allarampa.it",
  "description": "Cucina romana nel cuore del centro storico",
  "profileUrl": "https://www.paginegialle.it/ristorante-alla-rampa-roma",
  "searchQuery": "ristoranti",
  "searchLocation": "Roma"
}
```

### Tips for better results

- **Use Italian category names** — PagineGialle uses Italian terms: `ristoranti` (restaurants), `avvocati` (lawyers), `idraulici` (plumbers), `dentisti` (dentists), `agenzie immobiliari` (real estate agencies)
- **Target postcodes for high-density areas** — For cities like Roma or Milano, searching by postcode (e.g. `00187-roma`) returns more relevant results from specific districts
- **Run multiple queries** — Each query returns up to 25 results. Use multiple postcode queries for larger datasets
- **Enable residential proxy** — PagineGialle uses CloudFront WAF. Apify Residential Proxy provides the best reliability
- **Use Start URLs for exact control** — Build your own search URLs at [paginegialle.it/ricerca](https://www.paginegialle.it/ricerca/) and paste them as Start URLs

### Integrations

#### Google Sheets workflow

1. Run the actor with your target category and cities
2. Export dataset as CSV
3. Import into Google Sheets for mail merge or CRM upload

#### Zapier / Make.com automation

- Connect actor webhook to Zapier to auto-import new Italian leads into HubSpot, Salesforce, or Mailchimp
- Build a daily routine that scrapes new listings and appends them to your lead database

#### CRM integration via API

```javascript
// Node.js: Pull results directly into your CRM
const { ApifyClient } = require('apify-client');
const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });

const run = await client.actor('automation-lab/paginegialle-scraper').call({
  searchQueries: [{ what: 'ristoranti', where: 'Roma' }],
  maxResults: 100,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
// items now contains the business records
```

### API usage

#### Node.js

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_APIFY_API_TOKEN' });

const run = await client.actor('automation-lab/paginegialle-scraper').call({
  searchQueries: [
    { what: 'avvocati', where: 'Milano' },
    { what: 'avvocati', where: 'Roma' },
  ],
  maxResults: 200,
  proxyConfiguration: { useApifyProxy: true },
});

const dataset = await client.dataset(run.defaultDatasetId).listItems();
console.log(dataset.items);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_API_TOKEN")

run = client.actor("automation-lab/paginegialle-scraper").call(run_input={
    "searchQueries": [
        {"what": "idraulici", "where": "Napoli"},
        {"what": "elettricisti", "where": "Torino"},
    ],
    "maxResults": 100,
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["name"], item["phone"], item["city"])
```

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~paginegialle-scraper/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "searchQueries": [{"what": "ristoranti", "where": "Roma"}],
    "maxResults": 50
  }'
```

### Using with Claude and AI assistants (MCP)

You can use this actor directly from Claude Code, Claude Desktop, or any MCP-compatible AI assistant to scrape Italian business listings without writing code.

#### Claude Code setup

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/paginegialle-scraper"
```

#### Claude Desktop / Cursor / VS Code (JSON config)

```json
{
  "mcpServers": {
    "apify": {
      "command": "npx",
      "args": ["-y", "@apify/mcp-server"],
      "env": {
        "APIFY_TOKEN": "YOUR_APIFY_API_TOKEN",
        "ACTORS": "automation-lab/paginegialle-scraper"
      }
    }
  }
}
```

#### Example Claude prompts

- *"Scrape 50 restaurants in Rome from PagineGialle and give me their phone numbers in a table"*
- *"Find all dentists in Milan from PagineGialle and export as CSV"*
- *"Get me the top 25 lawyers listed on PagineGialle in Naples with their contact info"*

### Legal and compliance

**Legality:** This actor collects only **publicly available** business information that PagineGialle.it makes accessible without authentication. Business contact data (name, phone, address) is published by businesses themselves for marketing purposes.

You are responsible for:

- Complying with GDPR and Italian data protection law (D.Lgs. 196/2003) when storing or processing Italian personal data
- Respecting PagineGialle.it's [Terms of Service](https://www.paginegialle.it/termini-e-condizioni)
- Using collected data only for lawful purposes (B2B outreach, market research, etc.)

This actor does not collect personal information about private individuals and does not bypass any authentication or access controls.

### FAQ

**Q: How many results can I get per search?**
A: Each search URL returns up to 25 results. To get more, use multiple queries with different locations or postcodes. For example, search "ristoranti" in "00100-roma", "00186-roma", "00187-roma" etc. to cover different Rome districts.

**Q: Why does PagineGialle sometimes block requests?**
A: PagineGialle uses CloudFront WAF to detect automated traffic. Enable **Apify Residential Proxy** in the proxy settings for best reliability. Datacenter proxies may be blocked. If you get failures, try increasing Max Request Retries to 5.

**Q: Can I search by postcode instead of city?**
A: Yes! In the Start URLs option, use URLs like `https://www.paginegialle.it/ricerca/ristoranti/00187-roma` to target specific postcodes.

**Q: Why is the website field empty for some businesses?**
A: Many small businesses on PagineGialle don't have a website listed. The actor extracts the website when available and returns `null` otherwise.

**Q: The category field shows things like "Parcheggio" — is that right?**
A: Yes — the `category` field shows the first service/feature keyword listed for the business (e.g. "Parcheggio" = parking available, "Tavoli all'aperto" = outdoor seating). For the searched business type, use the `searchQuery` field.

**Q: Does this work for all Italian regions?**
A: Yes — PagineGialle covers all Italian cities, municipalities, and postcodes. Use the city name or a postcode in the `where` field.

### Related scrapers

- [automation-lab/google-maps-scraper](https://apify.com/automation-lab/google-maps-scraper) — Scrape Google Maps business listings globally
- [automation-lab/yelp-scraper](https://apify.com/automation-lab/yelp-scraper) — Extract restaurant and business data from Yelp

# Actor input Schema

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

List of searches to perform. Each item needs a category (cosa) and a city/location (dove). Examples: 'ristoranti' + 'Roma', 'avvocati' + 'Milano', 'idraulici' + 'Napoli'.

## `startUrls` (type: `array`):

Direct PagineGialle.it listing URLs to scrape (e.g. https://www.paginegialle.it/ricerca/avvocati/milano). Use this for full URL control. Leave empty to use search queries above.

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

Maximum number of business listings to collect per search query. Set to 0 for unlimited (collects all pages).

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

Proxy settings for bypassing bot detection. Apify Residential Proxy gives the best success rate.

## `maxRequestRetries` (type: `integer`):

Number of retry attempts for failed requests.

## Actor input object example

```json
{
  "searchQueries": [
    {
      "what": "ristoranti",
      "where": "Roma"
    }
  ],
  "startUrls": [],
  "maxResults": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  },
  "maxRequestRetries": 3
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# 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": [
        {
            "what": "ristoranti",
            "where": "Roma"
        }
    ],
    "startUrls": [],
    "maxResults": 20,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    },
    "maxRequestRetries": 3
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/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 = {
    "searchQueries": [{
            "what": "ristoranti",
            "where": "Roma",
        }],
    "startUrls": [],
    "maxResults": 20,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
    "maxRequestRetries": 3,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/paginegialle-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 '{
  "searchQueries": [
    {
      "what": "ristoranti",
      "where": "Roma"
    }
  ],
  "startUrls": [],
  "maxResults": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  },
  "maxRequestRetries": 3
}' |
apify call automation-lab/paginegialle-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "PagineGialle Italy Business Directory Scraper",
        "description": "Scrape Italian business listings from PagineGialle.it — the Italian Yellow Pages. Search by category and city to collect leads with phone numbers, addresses, and websites.",
        "version": "0.1",
        "x-build-id": "4gUqviawYMsnnOz9f"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~paginegialle-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-paginegialle-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/automation-lab~paginegialle-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-paginegialle-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/automation-lab~paginegialle-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-paginegialle-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": {
                    "searchQueries": {
                        "title": "🔍 Search queries",
                        "type": "array",
                        "description": "List of searches to perform. Each item needs a category (cosa) and a city/location (dove). Examples: 'ristoranti' + 'Roma', 'avvocati' + 'Milano', 'idraulici' + 'Napoli'.",
                        "items": {
                            "type": "object",
                            "properties": {
                                "what": {
                                    "type": "string",
                                    "title": "Category (cosa)",
                                    "description": "Business category in Italian, e.g. ristoranti, avvocati, idraulici"
                                },
                                "where": {
                                    "type": "string",
                                    "title": "City / location (dove)",
                                    "description": "City or location in Italian, e.g. Roma, Milano, Napoli"
                                }
                            }
                        }
                    },
                    "startUrls": {
                        "title": "🔗 Start URLs",
                        "type": "array",
                        "description": "Direct PagineGialle.it listing URLs to scrape (e.g. https://www.paginegialle.it/ricerca/avvocati/milano). Use this for full URL control. Leave empty to use search queries above.",
                        "items": {
                            "type": "object",
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL",
                                    "description": "Full PagineGialle.it search URL"
                                }
                            }
                        }
                    },
                    "maxResults": {
                        "title": "Max results per query",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of business listings to collect per search query. Set to 0 for unlimited (collects all pages).",
                        "default": 50
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy settings for bypassing bot detection. Apify Residential Proxy gives the best success rate."
                    },
                    "maxRequestRetries": {
                        "title": "Max request retries",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Number of retry attempts for failed requests.",
                        "default": 3
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```