# ParuVendu Used Cars Scraper (`crawlerbros/paruvendu-cars-scraper`) Actor

Scrape used-car listings from ParuVendu.fr, a major French car classifieds marketplace. Search by make, model, price, year, mileage, fuel type, transmission, body type, seller type, and location.

- **URL**: https://apify.com/crawlerbros/paruvendu-cars-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Automation, E-commerce, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## ParuVendu Used Cars Scraper

Scrape used-car listings from [ParuVendu.fr](https://www.paruvendu.fr/), one of France's major car classifieds marketplaces. Search by make, model keyword, price range, year range, mileage range, fuel type, transmission, body type, seller type (dealer/private), and location — get full listing details including photos and description. No login, no cookies, no paid proxy required.

### What this actor does

- **Search by make** across 90+ car brands (Renault, Peugeot, Citroën, BMW, Mercedes, Audi, Volkswagen, Toyota, and every other brand sold on the French used-car market)
- **Filters:** model/keyword, price range, year range, mileage range, fuel type (petrol/diesel/LPG/electric/hybrid/hydrogen), transmission (manual/automatic/semi-automatic), body type (sedan/SUV/estate/convertible/coupe/minivan/company car), seller type (dealer vs. private), location (city/postal code) with search radius, fiscal power range
- **Sort order:** newest first (default), price ascending/descending, mileage ascending/descending, or listings-with-photos-first — matching ParuVendu.fr's own sort dropdown
- **Two-stage enrichment:** every listing's detail page is fetched to pull the full set of fields (all photos, description, seller name/phone/address, color) via the page's structured `schema.org/Vehicle` data
- **Empty fields are omitted** — every field returned in a record is guaranteed to hold real data

### Output per listing

- `listingId`, `title`, `description`
- `price`, `currency`
- `make`, `model`
- `year`, `mileageKm`
- `fuelType`, `transmission`, `bodyType`, `color`, `driveType` (e.g. front/rear/all-wheel drive)
- `doors`, `seatingCapacity`, `co2EmissionsGKm`, `enginePowerHp` — when the listing's detail page publishes them
- `sellerType` (`dealer` or `private`), `sellerName`, `sellerPhone`
- `city`, `postalCode`, `location`
- `photos[]` — all listing photo URLs
- `listingUrl`
- `recordType: "carListing"`, `scrapedAt`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `make` | string (select) | `Renault` | Car brand — required, drives the base search page |
| `modelKeyword` | string | – | Free-text model/keyword filter (e.g. `Clio`, `dCi`) |
| `priceMin` / `priceMax` | int | – | Price range in EUR |
| `yearMin` / `yearMax` | int | – | First-registration year range |
| `mileageMin` / `mileageMax` | int | – | Odometer range in km |
| `fuelType` | string (select) | any | Essence / Diesel / GPL-GNL / BioEthanol / Électrique / Hybride / Hybride rechargeable / Micro Hybride / Hydrogène (single-select — see Limitations) |
| `transmission` | string (select) | any | Manuelle / Automatique / Semi automatique |
| `bodyType` | string (select) | any | Berline / 4x4-SUV / Break / Cabriolet / Coupé / Monospace / Véhicule de société |
| `sellerType` | string (select) | any | Professionnels (dealers) / Particuliers (private) |
| `location` | string | – | City name or postal code |
| `radiusKm` | string (select) | – | Search radius around `location`: 5/15/30/50/100 km |
| `fiscalPowerMin` / `fiscalPowerMax` | int | – | French fiscal horsepower (CV) range |
| `sortOrder` | string (select) | newest first | `priceAsc` / `priceDesc` / `mileageAsc` / `mileageDesc` / `withPhotoFirst` |
| `maxItems` | int | `30` | Hard cap on emitted records (1–1000) |

#### Example: diesel Renault Clio under 15,000€, 2018+

```json
{
  "make": "Renault",
  "modelKeyword": "Clio",
  "priceMax": 15000,
  "yearMin": 2018,
  "fuelType": "DI",
  "maxItems": 50
}
````

#### Example: automatic BMW SUVs from dealers near Lyon

```json
{
  "make": "BMW",
  "bodyType": "4X",
  "transmission": "AU",
  "sellerType": "on",
  "location": "Lyon",
  "radiusKm": "50",
  "maxItems": 40
}
```

### Use cases

- **Price research** — track used-car pricing trends by make/model/year in the French market
- **Dealer inventory monitoring** — watch a region's dealer listings for a specific make
- **Market analysis** — compare fuel-type and transmission mix across body types
- **Lead generation** — surface private-seller listings matching a buying brief
- **Data feeds** — power a car-search aggregator or price-comparison tool with French listings

### Data source

ParuVendu.fr is a plain server-rendered site with no bot-detection layer, so this actor runs on plain HTTP requests with the free Apify proxy — no residential proxy, cookies, or login needed. (An earlier version of this actor targeted lacentrale.fr, France's largest car marketplace by traffic, but that site runs DataDome bot protection that blocks all Apify datacenter and Auto-proxy traffic, which would require a paid residential proxy to bypass — against this project's zero-cost policy. ParuVendu.fr was chosen as a real, freely-accessible French used-car marketplace covering the same market.)

### Limitations

- ParuVendu.fr's search pages are scoped per make (there's no unfiltered "all makes" search page), so `make` is required on every run. Use `modelKeyword` to narrow within a make.
- `fuelType` is single-select by design: ParuVendu.fr's own filter ANDs multiple fuel-type selections together instead of ORing them (a real quirk confirmed directly against the live site), so selecting e.g. both Essence and Diesel would silently return zero results — no single car has two fuel types. Run the actor once per fuel type if you need multiple.
- A small number of very low-volume/niche brands may return zero results if ParuVendu.fr has no active listings for them at request time — this reflects live marketplace inventory, not a scraper bug.
- `sellerType` is derived from the listing's structured seller data; on the rare listing where a detail page can't be fetched, seller type is omitted rather than guessed.
- **Pagination cap:** ParuVendu.fr caps each make/filter combination's search results to 5 pages (125 listings), even when the page reports thousands of total matches — this is a genuine, confirmed limit on the live site, not a scraper shortfall. To collect more than 125 listings for a popular make, run the actor multiple times with a narrower filter each time (e.g. split by price band or year range) and combine the datasets.

### FAQ

**Do I need a proxy or cookies?**  No. The actor uses only the free Apify `AUTO` proxy group, no login, no cookies.

**Why is `make` required?**  ParuVendu.fr's URL structure anchors every search to a make (or another category), so a make selection is required to build a valid search URL.

**How are photos sourced?**  Directly from each listing's `schema.org/Vehicle` structured data — the same photo URLs shown in the listing gallery on the site.

**How is seller type determined?**  From the listing detail page's structured seller data: `AutoDealer` → `dealer`, otherwise → `private`.

**How fresh is the data?**  Listings reflect ParuVendu.fr's live inventory at scrape time; the site updates continuously as sellers post and remove ads.

# Actor input Schema

## `make` (type: `string`):

Car make/brand to search within. ParuVendu.fr requires a make (or another category anchor) per search page, so this drives the base search URL.

## `modelKeyword` (type: `string`):

Optional free-text model or keyword (e.g. `Clio`, `Golf`, `dCi`). Matches listing titles server-side within the selected make.

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

Minimum listing price in euros.

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

Maximum listing price in euros.

## `yearMin` (type: `integer`):

Earliest first-registration year.

## `yearMax` (type: `integer`):

Latest first-registration year.

## `mileageMin` (type: `integer`):

Minimum odometer reading in kilometers.

## `mileageMax` (type: `integer`):

Maximum odometer reading in kilometers.

## `fuelType` (type: `string`):

Filter to a single fuel type. ParuVendu.fr's own filter ANDs multiple fuel selections together (which no single car can satisfy), so this is single-select to avoid silently returning zero results.

## `transmission` (type: `string`):

Filter by gearbox type.

## `bodyType` (type: `string`):

Filter by vehicle body/category.

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

Filter by dealer vs. private seller.

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

City name or postal code to search around, e.g. `Lyon` or `69000`. Combine with `radiusKm` to widen the search area.

## `radiusKm` (type: `string`):

Radius around `location` to include. Only applies when `location` is set.

## `fiscalPowerMin` (type: `integer`):

Minimum French fiscal horsepower (puissance fiscale).

## `fiscalPowerMax` (type: `integer`):

Maximum French fiscal horsepower (puissance fiscale).

## `sortOrder` (type: `string`):

Result ordering, matching ParuVendu.fr's own "Trier" dropdown. Default is the site's own default (most recently listed first).

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

Hard cap on emitted records. Note: ParuVendu.fr caps each make/filter combination to ~125 listings (5 pages) regardless of total inventory; run again with a narrower filter to collect more.

## Actor input object example

```json
{
  "make": "Renault",
  "fuelType": "",
  "transmission": "",
  "bodyType": "",
  "sellerType": "",
  "radiusKm": "",
  "sortOrder": "",
  "maxItems": 30
}
```

# 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 = {
    "make": "Renault",
    "fuelType": "",
    "transmission": "",
    "bodyType": "",
    "sellerType": "",
    "radiusKm": "",
    "sortOrder": "",
    "maxItems": 30
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/paruvendu-cars-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 = {
    "make": "Renault",
    "fuelType": "",
    "transmission": "",
    "bodyType": "",
    "sellerType": "",
    "radiusKm": "",
    "sortOrder": "",
    "maxItems": 30,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/paruvendu-cars-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 '{
  "make": "Renault",
  "fuelType": "",
  "transmission": "",
  "bodyType": "",
  "sellerType": "",
  "radiusKm": "",
  "sortOrder": "",
  "maxItems": 30
}' |
apify call crawlerbros/paruvendu-cars-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "ParuVendu Used Cars Scraper",
        "description": "Scrape used-car listings from ParuVendu.fr, a major French car classifieds marketplace. Search by make, model, price, year, mileage, fuel type, transmission, body type, seller type, and location.",
        "version": "0.1",
        "x-build-id": "dtXHHkEead4ckaPGh"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~paruvendu-cars-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-paruvendu-cars-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/crawlerbros~paruvendu-cars-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-paruvendu-cars-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/crawlerbros~paruvendu-cars-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-paruvendu-cars-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": [
                    "make"
                ],
                "properties": {
                    "make": {
                        "title": "Make",
                        "enum": [
                            "Renault",
                            "Peugeot",
                            "Citroën",
                            "Volkswagen",
                            "BMW",
                            "Mercedes",
                            "Audi",
                            "Ford",
                            "Opel",
                            "Toyota",
                            "Nissan",
                            "Fiat",
                            "Dacia",
                            "Seat",
                            "Skoda",
                            "Hyundai",
                            "Kia",
                            "Mini",
                            "Volvo",
                            "Mazda",
                            "Honda",
                            "Suzuki",
                            "Mitsubishi",
                            "Jeep",
                            "Land-Rover",
                            "Porsche",
                            "Alfa Romeo",
                            "Jaguar",
                            "DS",
                            "Smart",
                            "Subaru",
                            "Lexus",
                            "Chevrolet",
                            "Chrysler",
                            "Dodge",
                            "Cupra",
                            "MG",
                            "Tesla",
                            "BYD",
                            "Abarth",
                            "Aiways",
                            "Alpina",
                            "Alpine",
                            "Aston Martin",
                            "Austin",
                            "Auverland",
                            "Bentley",
                            "Buick",
                            "Cadillac",
                            "Caterham",
                            "Corvette",
                            "Daewoo",
                            "Daihatsu",
                            "Daimler",
                            "Donkervoort",
                            "Ferrari",
                            "Fisker",
                            "Foton",
                            "GMC",
                            "Hummer",
                            "Infiniti",
                            "Isuzu",
                            "Jaecco",
                            "Lada",
                            "Lamborghini",
                            "Lancia",
                            "Leapmotor",
                            "Lincoln",
                            "Lotus",
                            "Lynk & CO",
                            "Maserati",
                            "McLaren",
                            "Mega",
                            "Morgan",
                            "PGO",
                            "Plymouth",
                            "Polestar",
                            "Pontiac",
                            "Rolls-Royce",
                            "Rover",
                            "Saab",
                            "Santana",
                            "Seres",
                            "Ssangyong",
                            "TVR",
                            "Talbot",
                            "Triumph",
                            "Xpeng",
                            "Autres"
                        ],
                        "type": "string",
                        "description": "Car make/brand to search within. ParuVendu.fr requires a make (or another category anchor) per search page, so this drives the base search URL.",
                        "default": "Renault"
                    },
                    "modelKeyword": {
                        "title": "Model / keyword",
                        "type": "string",
                        "description": "Optional free-text model or keyword (e.g. `Clio`, `Golf`, `dCi`). Matches listing titles server-side within the selected make."
                    },
                    "priceMin": {
                        "title": "Price min (EUR)",
                        "minimum": 0,
                        "maximum": 500000,
                        "type": "integer",
                        "description": "Minimum listing price in euros."
                    },
                    "priceMax": {
                        "title": "Price max (EUR)",
                        "minimum": 0,
                        "maximum": 500000,
                        "type": "integer",
                        "description": "Maximum listing price in euros."
                    },
                    "yearMin": {
                        "title": "Year min",
                        "minimum": 1900,
                        "maximum": 2026,
                        "type": "integer",
                        "description": "Earliest first-registration year."
                    },
                    "yearMax": {
                        "title": "Year max",
                        "minimum": 1900,
                        "maximum": 2026,
                        "type": "integer",
                        "description": "Latest first-registration year."
                    },
                    "mileageMin": {
                        "title": "Mileage min (km)",
                        "minimum": 0,
                        "maximum": 500000,
                        "type": "integer",
                        "description": "Minimum odometer reading in kilometers."
                    },
                    "mileageMax": {
                        "title": "Mileage max (km)",
                        "minimum": 0,
                        "maximum": 500000,
                        "type": "integer",
                        "description": "Maximum odometer reading in kilometers."
                    },
                    "fuelType": {
                        "title": "Fuel type",
                        "enum": [
                            "",
                            "ES",
                            "DI",
                            "GP",
                            "BI",
                            "EL",
                            "HY",
                            "HR",
                            "MH",
                            "HD"
                        ],
                        "type": "string",
                        "description": "Filter to a single fuel type. ParuVendu.fr's own filter ANDs multiple fuel selections together (which no single car can satisfy), so this is single-select to avoid silently returning zero results.",
                        "default": ""
                    },
                    "transmission": {
                        "title": "Transmission",
                        "enum": [
                            "",
                            "MA",
                            "AU",
                            "SA"
                        ],
                        "type": "string",
                        "description": "Filter by gearbox type.",
                        "default": ""
                    },
                    "bodyType": {
                        "title": "Body type",
                        "enum": [
                            "",
                            "TO",
                            "4X",
                            "BR",
                            "CA",
                            "CO",
                            "MO",
                            "SO"
                        ],
                        "type": "string",
                        "description": "Filter by vehicle body/category.",
                        "default": ""
                    },
                    "sellerType": {
                        "title": "Seller type",
                        "enum": [
                            "",
                            "on",
                            "off"
                        ],
                        "type": "string",
                        "description": "Filter by dealer vs. private seller.",
                        "default": ""
                    },
                    "location": {
                        "title": "Location (city or postal code)",
                        "type": "string",
                        "description": "City name or postal code to search around, e.g. `Lyon` or `69000`. Combine with `radiusKm` to widen the search area."
                    },
                    "radiusKm": {
                        "title": "Search radius (km)",
                        "enum": [
                            "",
                            "5",
                            "15",
                            "30",
                            "50",
                            "100"
                        ],
                        "type": "string",
                        "description": "Radius around `location` to include. Only applies when `location` is set.",
                        "default": ""
                    },
                    "fiscalPowerMin": {
                        "title": "Fiscal power min (CV)",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Minimum French fiscal horsepower (puissance fiscale)."
                    },
                    "fiscalPowerMax": {
                        "title": "Fiscal power max (CV)",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum French fiscal horsepower (puissance fiscale)."
                    },
                    "sortOrder": {
                        "title": "Sort order",
                        "enum": [
                            "",
                            "priceAsc",
                            "priceDesc",
                            "mileageAsc",
                            "mileageDesc",
                            "withPhotoFirst"
                        ],
                        "type": "string",
                        "description": "Result ordering, matching ParuVendu.fr's own \"Trier\" dropdown. Default is the site's own default (most recently listed first).",
                        "default": ""
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Hard cap on emitted records. Note: ParuVendu.fr caps each make/filter combination to ~125 listings (5 pages) regardless of total inventory; run again with a narrower filter to collect more.",
                        "default": 30
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
