# Pagesjaunes Reviews Scraper (`reviewly/pagesjaunes-reviews-scraper`) Actor

Scrapes reviews from pagesjaunes.fr with full pagination, date filtering, review cap, and residential proxy support.

- **URL**: https://apify.com/reviewly/pagesjaunes-reviews-scraper.md
- **Developed by:** [Reviewly](https://apify.com/reviewly) (community)
- **Categories:** Automation, Other, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 record scrapeds

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

## PagesJaunes Reviews Scraper — Extract Customer Reviews at Scale

**Turn PagesJaunes customer reviews into structured data in minutes — no coding required.**

Monitor your brand reputation, research competitors, generate qualified leads, or feed review data into your platform. This Apify Actor scrapes all public reviews from any PagesJaunes business page and delivers clean, structured JSON — automatically.

- ✅ Scrapes all reviews with full pagination
- ✅ Filter by date to get only recent reviews
- ✅ Cap the number of reviews per company
- ✅ Built-in French residential proxies — no blocks
- ✅ Handles multiple companies in a single run

---

### 📌 What This Actor Does

[PagesJaunes](https://www.pagesjaunes.fr) is France's largest local business directory, with millions of verified customer reviews across every industry. This Actor lets you extract those reviews programmatically — without writing a single line of code.

Give it one or more PagesJaunes business URLs, configure your filters, and it returns a structured dataset containing company information and all matching reviews, ready for export to JSON, CSV, or any downstream tool.

**Who is this for?**
- **Marketers & agencies** tracking brand reputation for French clients
- **Businesses** monitoring what customers say about them or their competitors
- **Developers** building review aggregation platforms or dashboards
- **Sales teams** identifying leads based on competitor review patterns
- **Researchers & analysts** studying consumer sentiment in the French market

---

### ✨ Key Features

- **Full pagination** — scrapes every review page automatically, not just the first 25
- **Date filtering** — set a `targetDate` and only reviews published on or after that date are collected
- **Review cap** — set `maxNumberOfReviews` to limit how many reviews are collected per company (useful for large-scale runs)
- **Rich review data** — captures rating, review body, author, location, experience date, and business responses
- **Rating breakdown** — extracts the 1–5 star distribution for each company
- **Response detection** — captures the business's written reply to each review, including the response date
- **Platform attribution** — each review includes a `platform` field set to `"custplace"` or `"pagesjaunes"` so you know the origin of each review
- **Reliable retries** — exponential backoff with up to 10 retries per request, so transient errors don't stop your run
- **Anti-block design** — uses residential French proxies and Chrome browser fingerprinting to stay undetected

---

### 🧠 Why This Actor Is Different

Most PagesJaunes scrapers break after the first page or get blocked within minutes. This Actor was built for production use:

| Feature | This Actor | Typical scrapers |
|---|---|---|
| Full pagination | ✅ All pages | ❌ First page only |
| Proxy type | ✅ Residential FR | ⚠️ Datacenter (easily blocked) |
| Browser fingerprint | ✅ Chrome via `impit` | ❌ Plain HTTP |
| Retry logic | ✅ Exponential backoff (10×) | ❌ Fails on first error |
| Date filtering | ✅ Built-in | ❌ Manual post-processing |
| Business responses | ✅ Captured | ❌ Usually missed |
| Rating breakdown | ✅ Per star level | ❌ Aggregate only |

---

### ⚙️ Input Configuration

#### Fields

| Field | Type | Required | Default | Description |
|---|---|---|---|---|
| `startUrls` | array | ✅ Yes | — | One or more PagesJaunes company page URLs |
| `maxNumberOfReviews` | integer | No | `0` | Max reviews per company. `0` = no limit |
| `targetDate` | string | No | — | Only collect reviews on or after this date (YYYY-MM-DD) |
| `proxyConfiguration` | object | No | Residential FR | Proxy settings (see below) |

#### Example Input

```json
{
  "startUrls": [
    { "url": "https://www.pagesjaunes.fr/pros/53876558" },
    { "url": "https://www.pagesjaunes.fr/pros/61558803" }
  ],
  "maxNumberOfReviews": 500,
  "targetDate": "2024-01-01",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"],
    "apifyProxyCountry": "FR"
  }
}
````

#### Input Tips

- **Finding the URL**: navigate to any company page on pagesjaunes.fr and copy the URL from your browser. It will look like `https://www.pagesjaunes.fr/pros/XXXXXXXX`.
- **`targetDate`**: use this when you only need recent reviews — for example, set it to 30 days ago for a monthly monitoring workflow. This reduces cost and runtime significantly.
- **`maxNumberOfReviews`**: leave it at `0` to scrape all reviews. Set a number (e.g. `100`) if you only need a sample or want to control cost.
- **Proxy**: the default residential French proxy is strongly recommended. PagesJaunes uses geo-based bot detection and datacenter IPs are frequently blocked.

***

### 📤 Output Format

Each dataset item corresponds to one company URL. It contains two top-level keys: `entity` (company metadata) and `reviews` (array of review objects).

#### Sample Output

```json
{
  "entity": {
    "keyword": "Plombier Martin - Paris 11",
    "totalRating": 4.7,
    "totalReviews": 312,
    "ratingDetails": {
      "1": 5,
      "2": 8,
      "3": 14,
      "4": 42,
      "5": 243
    },
    "url": "https://www.pagesjaunes.fr/pros/53876558"
  },
  "reviews": [
    {
      "reviewId": "Avis-12345678",
      "url": "https://www.pagesjaunes.fr/pros/53876558#Avis-12345678",
      "location": "Paris (75011)",
      "reviewBody": "Intervention rapide et travail soigné. Je recommande vivement.",
      "reviewRating": 5,
      "reviewDate": "2024-11-15T00:00:00.000Z",
      "experienceDate": "2024-11-10T00:00:00.000Z",
      "author": {
        "userName": "Sophie M."
      },
      "response": {
        "reviewResponse": "Merci beaucoup pour votre retour, Sophie ! C'est un plaisir de vous avoir aidé.",
        "responseDate": "2024-11-16T00:00:00.000Z"
      },
      "platform": "pagesjaunes"
    }
  ]
}
```

#### Field Reference

**Entity fields**

| Field | Type | Description |
|---|---|---|
| `keyword` | string | Company name as displayed on PagesJaunes |
| `totalRating` | number | Overall average rating (1.0–5.0) |
| `totalReviews` | integer | Total number of reviews on the platform |
| `ratingDetails` | object | Count of reviews per star level (1–5) |
| `url` | string | The input URL that was scraped |

**Review fields**

| Field | Type | Description |
|---|---|---|
| `reviewId` | string | Unique review identifier (e.g. `Avis-12345678`) |
| `url` | string | Direct link to the review on PagesJaunes |
| `location` | string | Reviewer's city/region (if provided) |
| `reviewBody` | string | Full text of the review |
| `reviewRating` | number | Star rating given (1–5) |
| `reviewDate` | string (ISO 8601) | Date the review was published |
| `experienceDate` | string (ISO 8601) | Date of the customer's experience (if provided) |
| `author.userName` | string | Display name of the reviewer |
| `response.reviewResponse` | string | Business's written reply (if any) |
| `response.responseDate` | string (ISO 8601) | Date the business replied |
| `platform` | string | Origin of the review: `"custplace"` or `"pagesjaunes"` |

***

### ▶️ How to Use

#### Option 1 — Apify Console (No Code)

1. Open the Actor page in the [Apify Store](https://apify.com/store)
2. Click **Try for free**
3. In the **Input** tab, paste one or more PagesJaunes URLs into the **Start URLs** field
4. (Optional) Set a **Target Date** and/or **Max Reviews**
5. Click **Start** — the run will begin immediately
6. When finished, go to the **Dataset** tab to preview or download results as JSON or CSV

#### Option 2 — Apify API

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/YOUR_ACTOR_ID/runs?token=YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "startUrls": [{ "url": "https://www.pagesjaunes.fr/pros/53876558" }],
    "targetDate": "2024-06-01",
    "maxNumberOfReviews": 200
  }'
```

#### Option 3 — Apify SDK (JavaScript)

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

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

const run = await client.actor('YOUR_ACTOR_ID').call({
  startUrls: [{ url: 'https://www.pagesjaunes.fr/pros/53876558' }],
  targetDate: '2024-06-01',
  maxNumberOfReviews: 200,
});

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

***

### 📈 Use Cases

#### 1. Brand Reputation Monitoring

Schedule the Actor to run weekly with a `targetDate` set to 7 days ago. Get only new reviews delivered to your dataset automatically. Feed results into Slack, email, or a dashboard to stay on top of what customers are saying.

#### 2. Competitor Analysis

Collect reviews from competitors in your industry. Compare average ratings, star distributions, and recurring themes in review text to identify gaps in their service — and opportunities for yours.

#### 3. Lead Generation

Find businesses with declining ratings or a high proportion of negative reviews. These companies often need reputation management services, review response tools, or operational improvements. Export results to a CRM for targeted outreach.

#### 4. Review Aggregation Platform

If you're building a review aggregation or comparison tool for the French market, use this Actor as your PagesJaunes data source. Results are clean JSON, ready to store in any database.

#### 5. Customer Sentiment Research

Analyse review bodies at scale using NLP or AI tools to extract recurring topics, sentiment trends, or emerging issues across an industry vertical in France.

***

### 🛠️ Advanced Tips

#### Running Multiple Companies Efficiently

Pass all your URLs in a single `startUrls` array. The Actor processes them sequentially with a fresh proxy per company, which is more reliable than running separate Actor instances.

#### Incremental Scraping (Monitoring Workflows)

Use `targetDate` set to your last run date to fetch only new reviews on each run. This keeps costs low and avoids re-processing data you already have. Combine with Apify Scheduler for fully automated monitoring.

#### Controlling Cost with `maxNumberOfReviews`

For companies with thousands of reviews, set `maxNumberOfReviews` to a reasonable cap (e.g. `500`) if you don't need the entire history. Reviews are returned newest-first, so you'll always get the most recent ones.

#### Exporting to Google Sheets or CSV

In the Apify Console, after a run completes, click **Export** in the Dataset tab and choose **CSV**. You can also connect directly to Google Sheets using Apify's [Google Sheets integration](https://apify.com/apify/google-sheets-import-export).

#### Proxy Country

The default proxy country is `FR` (France). PagesJaunes serves content based on geography, so keeping the country set to France gives you accurate data and avoids geo-based redirects.

***

### ❓ FAQ & Troubleshooting

**Q: The Actor finishes but the dataset is empty.**
Make sure the URL you provided is a valid PagesJaunes company page in the format `https://www.pagesjaunes.fr/pros/XXXXXXXX`. Category pages or search result pages will be skipped. Check the Actor log for a "URL not found" message.

**Q: Can I scrape any PagesJaunes URL?**
Currently the Actor supports company profile pages (`/pros/...`). Category search pages or map views are not supported.

**Q: How many reviews can it scrape?**
There is no hard limit. The Actor will paginate through all available reviews unless you set `maxNumberOfReviews`. Runs with thousands of reviews may take several minutes.

**Q: Will PagesJaunes block the scraper?**
The Actor uses residential French proxies and Chrome browser fingerprinting, which makes requests indistinguishable from a real browser. Exponential backoff retries handle any transient blocks automatically.

**Q: How fresh is the data?**
Every run fetches live data directly from PagesJaunes — there is no caching. You get the current state of reviews at the time you run the Actor.

**Q: What does the `platform` field mean?**
Some reviews on PagesJaunes were collected via [Custplace](https://www.custplace.com), a verified reviews platform. The `platform` field will be `"custplace"` for those reviews and `"pagesjaunes"` for organically written ones, so you can distinguish between verified post-transaction reviews and direct reviews.

**Q: The `experienceDate` is `null` for some reviews.**
PagesJaunes only shows the experience date when the reviewer explicitly provides it. When it's absent, the field will be `null`.

**Q: Can I get notified when new reviews appear?**
Yes — use Apify Scheduler to run the Actor on a regular interval with `targetDate` set to your previous run date. Combine with a webhook to push new results to Slack, email, or any webhook endpoint.

***

### 📞 Support

For questions, bug reports, or feature requests:

- 📧 Email: <me@ahmedhrid.com>
- 🐛 GitHub Issues: open an issue on this repository
- 💬 Apify Community: [community.apify.com](https://community.apify.com)

# Actor input Schema

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

One or more pagesjaunes.fr company page URLs (e.g. https://www.pagesjaunes.fr/pros/53876558).

## `maxNumberOfReviews` (type: `integer`):

Maximum number of reviews to collect per company. Set to 0 (or leave empty) for no limit.

## `targetDate` (type: `string`):

Only collect reviews published on or after this date. Leave empty to collect all reviews.

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

Proxy servers used to avoid rate limiting and blocks. French residential proxies are recommended for pagesjaunes.fr.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.pagesjaunes.fr/pros/53876558"
    }
  ],
  "maxNumberOfReviews": 0,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "FR"
  }
}
```

# Actor output Schema

## `dataset` (type: `string`):

Each item contains an `entity` object and a `reviews` array. Review fields: reviewId, url, location, reviewBody, reviewRating, reviewDate, experienceDate, author, response, platform.

# 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 = {
    "startUrls": [
        {
            "url": "https://www.pagesjaunes.fr/pros/53876558"
        }
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "FR"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("reviewly/pagesjaunes-reviews-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 = {
    "startUrls": [{ "url": "https://www.pagesjaunes.fr/pros/53876558" }],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "FR",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("reviewly/pagesjaunes-reviews-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 '{
  "startUrls": [
    {
      "url": "https://www.pagesjaunes.fr/pros/53876558"
    }
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "FR"
  }
}' |
apify call reviewly/pagesjaunes-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Pagesjaunes Reviews Scraper",
        "description": "Scrapes reviews from pagesjaunes.fr with full pagination, date filtering, review cap, and residential proxy support.",
        "version": "0.0",
        "x-build-id": "OwJehkfuLkzHxdDYr"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/reviewly~pagesjaunes-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-reviewly-pagesjaunes-reviews-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/reviewly~pagesjaunes-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-reviewly-pagesjaunes-reviews-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/reviewly~pagesjaunes-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-reviewly-pagesjaunes-reviews-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",
                "required": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "Company Review URLs",
                        "type": "array",
                        "description": "One or more pagesjaunes.fr company page URLs (e.g. https://www.pagesjaunes.fr/pros/53876558).",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxNumberOfReviews": {
                        "title": "Max reviews per company",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of reviews to collect per company. Set to 0 (or leave empty) for no limit.",
                        "default": 0
                    },
                    "targetDate": {
                        "title": "Filter reviews on or after date",
                        "type": "string",
                        "description": "Only collect reviews published on or after this date. Leave empty to collect all reviews."
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy servers used to avoid rate limiting and blocks. French residential proxies are recommended for pagesjaunes.fr.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
