# Leboncoin Scraper - Listings, Ad Details, Sellers (`sourabhbgp/leboncoin-scraper`) Actor

Scrape Leboncoin.fr, France's largest classifieds marketplace: search listings, full ad details with descriptions, and seller profiles with reviews. Covers every category including cars, real estate, and jobs. Export to JSON, CSV, or Excel.

- **URL**: https://apify.com/sourabhbgp/leboncoin-scraper.md
- **Developed by:** [Sourabh Kumar](https://apify.com/sourabhbgp) (community)
- **Categories:** E-commerce, Real estate, Jobs
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 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.

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

### Leboncoin scraper - search listings, ad details, seller profiles & reviews

One actor for the whole of Leboncoin.fr: search any category, pull full ad details with descriptions, and scrape seller profiles with their reviews. Cars, real estate, jobs, and every other category work the same way.

**$3 per 1,000 results. Flat for every mode.**

Built for France's #1 classifieds. Bot protection is handled for you, so most runs finish in under a minute.

### Why this scraper?

- 💶 **Flat $3 per 1,000 records** across every mode. No surprise tiers.
- 🧩 **Three modes in one actor** instead of stitching together a separate scraper for search, details, and sellers.
- 📝 **Full descriptions, all images, and the seller's SIREN** on every ad detail, plus an option to add them to search results.
- ⭐ **Seller profiles with their review texts** - rating, response time, services, badges, and the full listings catalog. Almost no one else returns the reviews.
- 🚗 **Every category, parsed properly.** Cars get mileage, fuel, and gearbox; property gets DPE energy class, surface, and rooms; the rest get their own attributes too.
- ✅ **No setup.** Bot protection and proxies are handled for you, with automatic retries on the rare block.
- 🧾 **Bad input never bills you.** A wrong URL or empty query exits cleanly with a message, not a charge.

### What data can you extract?

<table>
  <tr><td>🆔 Ad ID & URL</td><td>📝 Title & description</td><td>💶 Price</td><td>🗂️ Category</td></tr>
  <tr><td>🖼️ All images</td><td>📍 City, zip & GPS</td><td>👤 Seller name & type</td><td>🏢 SIREN / SIRET</td></tr>
  <tr><td>⭐ Seller rating</td><td>💬 Seller reviews</td><td>❤️ Favorites count</td><td>📅 Publish date</td></tr>
  <tr><td>🚗 Car specs</td><td>🏠 Property DPE & surface</td><td>🔧 Category attributes</td><td>🏷️ Pro / private</td></tr>
</table>

### Scraping modes

#### 🔎 Search
Pull listings from a keyword, a category, structured filters (price, seller type, location), or any Leboncoin search URL you paste. Returns rich records: title, price, images, location, seller, and category attributes. Turn on `enrichDescriptions` to add the full description and SIREN to each result.

```json
{ "mode": "search", "searchQuery": "iphone 15", "maxItems": 100 }
````

#### 📄 Ad detail

Give it full ad URLs and get the full ad: complete description, every image, all category attributes, and the seller's business details.

```json
{ "mode": "detail", "adUrls": ["https://www.leboncoin.fr/ad/voitures/3164356345"] }
```

#### 🏪 Seller

Paste a seller's profile or shop URL and get their full profile - store info, rating, review texts, services, response rate, badges - plus every listing they have live.

```json
{ "mode": "seller", "sellerUrls": ["https://www.leboncoin.fr/profil/ced112f9-7c90-41f2-923d-dfcac68b2a58"], "maxItems": 50 }
```

### How to scrape Leboncoin: step by step

1. [Create a free Apify account](https://console.apify.com/sign-up). Takes 30 seconds, no card needed.
2. Open [Leboncoin Scraper](https://console.apify.com/actors/IauueEbPIKrplV3O8?addFromActorId=IauueEbPIKrplV3O8) in the Apify Console.
3. Pick a mode and paste your keyword, URL, or ad list.
4. Click **Start**. Most runs finish in under a minute.
5. Export as JSON, CSV, or Excel, or pull the results from the API.

### How much does Leboncoin Scraper cost?

You pay **$3 per 1,000 records**. The Apify Free plan includes $5 of monthly usage credits, about **1,650 records**. The $29/month Starter plan covers about **9,600 records** a month. There is a small per-run start fee.

### Input

```json
{
  "mode": "search",
  "searchQuery": "renault clio",
  "category": "2",
  "priceMin": 5000,
  "priceMax": 15000,
  "sellerType": "pro",
  "locations": "Lyon",
  "enrichDescriptions": false,
  "maxItems": 100
}
```

| Field | Type | Default | Notes |
|---|---|---|---|
| `mode` | string | `search` | `search`, `detail`, or `seller`. |
| `searchQuery` | string | - | Keyword for search mode. |
| `startUrls` | array | - | Full Leboncoin search or category URLs (search mode). Best way to apply advanced or radius filters. |
| `category` | string | - | Category ID, e.g. `2` cars, `9` property sales, `10` rentals, `22` fashion, `33` jobs. |
| `locations` | string | - | French city or area, e.g. `Paris`, `Lyon`, `Bordeaux`. |
| `priceMin` / `priceMax` | integer | - | Price range for search. |
| `sellerType` | string | `all` | `all`, `pro`, or `private`. |
| `adUrls` | array | - | Full Leboncoin ad URLs (detail mode). |
| `sellerUrls` | array | - | Seller profile or shop URLs, a user ID, or a boutique ID (seller mode). |
| `includeSellerListings` | boolean | `true` | Seller mode: also return the seller's listings. |
| `enrichDescriptions` | boolean | `false` | Search: add full description and SIREN per ad (one extra request each). |
| `maxItems` | integer | `100` | Cap on records per run. |
| `maxConcurrency` | integer | `6` | Parallel requests for detail and seller modes. |

### Output

Search result (description is added only with `enrichDescriptions`):

```json
{
  "recordType": "ad",
  "listId": "3140598397",
  "url": "https://www.leboncoin.fr/ad/voitures/3140598397",
  "title": "Renault Clio 1.5 Blue dCi 115ch Zen",
  "description": null,
  "price": 13499,
  "currency": "EUR",
  "categoryName": "Voitures",
  "location": { "city": "Lille", "zipcode": "59160", "department": "Nord", "lat": 50.639, "lng": 3.012 },
  "seller": { "name": "RENAULT LOMME", "type": "pro", "siren": "428804868" },
  "vehicle": { "brand": "Renault", "model": "Clio", "regdate": "2026", "mileage": "12000 km", "fuel": "Diesel", "gearbox": "Manuelle" },
  "imageCount": 30
}
```

Ad detail adds the full description, the seller's SIREN, and the favorites count:

```json
{
  "recordType": "ad",
  "title": "Maison 4 pièces 86 m²",
  "price": 255000,
  "description": "Maison de plain-pied avec jardin...",
  "favorites": 76,
  "realEstate": { "real_estate_type": "Maison", "square": "86 m²", "rooms": "4", "energy_rate": "C", "ges": "C", "price_per_square_meter": "2965" }
}
```

Seller profile (seller mode adds one of these, then one row per listing):

```json
{
  "recordType": "seller",
  "sellerProfile": {
    "name": "AGENCY CAR",
    "siret": "99289838700012",
    "city": "BROGNARD",
    "website": "https://www.agencycar.fr",
    "ratingValue": 5,
    "ratingCount": 30,
    "responseRate": 100,
    "services": ["Reprise de véhicules", "Dépôt-Vente", "Vente de véhicules"],
    "badges": ["Responsiveness3", "VerifiedPhoneNumber"],
    "listingsTotal": 40
  },
  "reviews": [
    { "author": "Joanie Rabotot", "rating": 5, "text": "Simple, rapide et efficace...", "time": "2026-02-26T17:54:44Z" }
  ]
}
```

Use `recordType` to tell ad rows from seller rows.

### Use cases

- 📊 **Market & price research** - Track asking prices and inventory across a whole category or region.
- 🚗 **Used-car intelligence** - Compare mileage, fuel, and price for any make and model at scale.
- 🏠 **Real-estate analysis** - Pull surface, rooms, and DPE energy class for listings in a city.
- 🧲 **Lead generation** - Surface pro sellers with their SIREN, website, and services.
- ⭐ **Reputation monitoring** - Collect a seller's rating and review texts over time.
- 🛒 **Resale & arbitrage** - Spot underpriced listings the moment they appear.

### Limitations

- **Descriptions need a detail fetch.** Leboncoin does not put descriptions in search results, so `enrichDescriptions` (or detail mode) adds one request per ad.
- **About 640 results per search query.** Leboncoin's pages stop returning fresh listings past that depth. To pull more, split the query by price band, sub-category, or location: each slice returns its own set.
- **Seller mode is for pro and shop sellers.** Private sellers do not have a public profile page.
- **France only.** This scraper targets leboncoin.fr.
- **Public data only.** It reaches what a logged-out visitor can see.

### FAQ

#### How much does Leboncoin Scraper cost?

Leboncoin Scraper uses pay-per-result pricing. You pay **$3 for 1,000 results**. The Apify Free plan gives you $5 in usage credits a month, enough for around 1,650 results. If you run regularly, the $29/month Starter plan covers about 9,600 results.

No subscription lock-in. Pause whenever.

#### Is it legal to scrape Leboncoin?

Scraping public data is generally allowed in the US and most of the EU, as long as you don't collect personal data covered by GDPR or CCPA without a lawful basis. This actor only touches publicly accessible pages, but how you use the output is on you.

Apify's full breakdown: [Is web scraping legal?](https://blog.apify.com/is-web-scraping-legal/).

#### Can I integrate Leboncoin Scraper with other tools?

Push results into **Make, Zapier, Slack, Airbyte, GitHub, Google Sheets, Google Drive**, and more. Apify treats every actor as a webhook source, so anything that consumes webhooks or pulls from an API works.

Full list: [Apify integrations](https://docs.apify.com/platform/integrations).

#### Can I use Leboncoin Scraper with the Apify API?

Yes. Every run is available via the Apify REST API:

```bash
curl -X POST "https://api.apify.com/v2/acts/sourabhbgp~leboncoin-scraper/runs?token=APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"mode": "search", "searchQuery": "iphone"}'
```

Docs: [Apify API reference](https://docs.apify.com/api/v2).

#### Can I use Leboncoin Scraper through an MCP Server?

Yes. Apify ships an MCP server that exposes every actor as a tool, so Claude Desktop, Cursor, and any other MCP-capable client can call Leboncoin Scraper. Setup: [Apify MCP docs](https://docs.apify.com/platform/integrations/mcp).

### Your feedback

Bug, missing field, or odd behavior? Drop a note in the [Issues tab](https://console.apify.com/actors/IauueEbPIKrplV3O8/issues). Reports go to a human and fixes usually ship the same week.

# Actor input Schema

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

What to scrape. Search returns listings from a query or URL. Detail returns a full ad (description, all images, seller SIREN). Seller returns a seller profile, reviews and their listings.

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

Keyword for search mode, e.g. iphone 15.

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

Paste full Leboncoin search or category URLs (search mode). Overrides the keyword and structured filters.

## `category` (type: `string`):

Restrict search to a category ID, e.g. 2 vehicles, 9 property sales, 10 rentals.

## `locations` (type: `string`):

Restrict search to a French city or area, e.g. Paris, Lyon, Bordeaux. For a precise radius paste a full search URL into Search / category URLs instead. Leave blank for all of France.

## `priceMin` (type: `integer`):

Minimum price filter for search.

## `priceMax` (type: `integer`):

Maximum price filter for search.

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

Filter search by seller type.

## `adUrls` (type: `array`):

Full Leboncoin ad URLs (detail mode), e.g. https://www.leboncoin.fr/ad/voitures/3164356345.

## `sellerUrls` (type: `array`):

Leboncoin /boutique/ or /profil/ URLs, a seller user ID (UUID), or a numeric boutique ID (seller mode). Pro/shop sellers only: private sellers have no public profile page.

## `includeSellerListings` (type: `boolean`):

Seller mode: also return the seller's active listings.

## `enrichDescriptions` (type: `boolean`):

Search mode: fetch each result's full description, all images and seller SIREN with an extra request per ad. Costs one result event per ad, slower. Off by default.

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

Maximum records to return for the run.

## `maxConcurrency` (type: `integer`):

Parallel requests across URLs, sellers and ads.

## Actor input object example

```json
{
  "mode": "search",
  "searchQuery": "iphone",
  "startUrls": [],
  "sellerType": "all",
  "adUrls": [],
  "sellerUrls": [],
  "includeSellerListings": true,
  "enrichDescriptions": false,
  "maxItems": 100,
  "maxConcurrency": 6
}
```

# Actor output Schema

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

View the scraped records in the dataset.

# 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": [],
    "adUrls": [],
    "sellerUrls": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("sourabhbgp/leboncoin-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": [],
    "adUrls": [],
    "sellerUrls": [],
}

# Run the Actor and wait for it to finish
run = client.actor("sourabhbgp/leboncoin-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": [],
  "adUrls": [],
  "sellerUrls": []
}' |
apify call sourabhbgp/leboncoin-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Leboncoin Scraper - Listings, Ad Details, Sellers",
        "description": "Scrape Leboncoin.fr, France's largest classifieds marketplace: search listings, full ad details with descriptions, and seller profiles with reviews. Covers every category including cars, real estate, and jobs. Export to JSON, CSV, or Excel.",
        "version": "0.0",
        "x-build-id": "eBy9KIf6ofGCchJoy"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/sourabhbgp~leboncoin-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-sourabhbgp-leboncoin-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/sourabhbgp~leboncoin-scraper/runs": {
            "post": {
                "operationId": "runs-sync-sourabhbgp-leboncoin-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/sourabhbgp~leboncoin-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-sourabhbgp-leboncoin-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": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search",
                            "detail",
                            "seller"
                        ],
                        "type": "string",
                        "description": "What to scrape. Search returns listings from a query or URL. Detail returns a full ad (description, all images, seller SIREN). Seller returns a seller profile, reviews and their listings.",
                        "default": "search"
                    },
                    "searchQuery": {
                        "title": "Search keyword",
                        "type": "string",
                        "description": "Keyword for search mode, e.g. iphone 15.",
                        "default": "iphone"
                    },
                    "startUrls": {
                        "title": "Search / category URLs",
                        "type": "array",
                        "description": "Paste full Leboncoin search or category URLs (search mode). Overrides the keyword and structured filters.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "category": {
                        "title": "Category ID",
                        "type": "string",
                        "description": "Restrict search to a category ID, e.g. 2 vehicles, 9 property sales, 10 rentals."
                    },
                    "locations": {
                        "title": "Location filter",
                        "type": "string",
                        "description": "Restrict search to a French city or area, e.g. Paris, Lyon, Bordeaux. For a precise radius paste a full search URL into Search / category URLs instead. Leave blank for all of France."
                    },
                    "priceMin": {
                        "title": "Min price (EUR)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum price filter for search."
                    },
                    "priceMax": {
                        "title": "Max price (EUR)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum price filter for search."
                    },
                    "sellerType": {
                        "title": "Seller type",
                        "enum": [
                            "all",
                            "pro",
                            "private"
                        ],
                        "type": "string",
                        "description": "Filter search by seller type.",
                        "default": "all"
                    },
                    "adUrls": {
                        "title": "Ad URLs",
                        "type": "array",
                        "description": "Full Leboncoin ad URLs (detail mode), e.g. https://www.leboncoin.fr/ad/voitures/3164356345.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "sellerUrls": {
                        "title": "Seller URLs or IDs",
                        "type": "array",
                        "description": "Leboncoin /boutique/ or /profil/ URLs, a seller user ID (UUID), or a numeric boutique ID (seller mode). Pro/shop sellers only: private sellers have no public profile page.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "includeSellerListings": {
                        "title": "Include seller listings",
                        "type": "boolean",
                        "description": "Seller mode: also return the seller's active listings.",
                        "default": true
                    },
                    "enrichDescriptions": {
                        "title": "Fetch full descriptions (search)",
                        "type": "boolean",
                        "description": "Search mode: fetch each result's full description, all images and seller SIREN with an extra request per ad. Costs one result event per ad, slower. Off by default.",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum records to return for the run.",
                        "default": 100
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "maximum": 12,
                        "type": "integer",
                        "description": "Parallel requests across URLs, sellers and ads.",
                        "default": 6
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
