# France Pige Pro — FSBO Real Estate Leads Across 4 Portals (`studio-amba/france-pige-pro`) Actor

Find FSBO (private-owner) property leads in France. Runs SeLoger, Bien'ici, Logic-Immo and LeBonCoin, dedupes each property across portals by a postcode + surface + price fingerprint, and flags every result private-seller or agency-listed. New-listing delta and optional agency enrichment.

- **URL**: https://apify.com/studio-amba/france-pige-pro.md
- **Developed by:** [Studio Amba](https://apify.com/studio-amba) (community)
- **Categories:** Real estate, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 deduplicated properties

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

## France Pige Pro — FSBO Real Estate Leads

Find **private-owner property leads** ("pige particulier" / FSBO — for sale by owner) across the main French real-estate portals in one run. France Pige Pro runs Bien'ici and LeBonCoin (SeLoger and Logic-Immo optional), deduplicates the same physical property across portals, and flags every result as sold by a **private owner** or by an **agency**.

This is the lead French prospection teams pay Pige Online and Melo €100+/month for: owners selling without a mandate, before an agency signs them.

### What it does

- **FSBO detection.** LeBonCoin exposes an explicit private-vs-professional seller flag. Every LeBonCoin private listing becomes a lead, with the seller name and a phone-available flag where exposed.
- **Cross-portal dedup.** The same property listed on more than one portal is merged into a single row using a content fingerprint (postcode + property type + surface, then price proximity). No shared listing ID exists between French portals, so the match is content-based.
- **Agency vs private classification.** Agency listings carry an agency name; private LeBonCoin listings carry the explicit private flag. Everything is labelled `particulier`, `professionnel`, or `unknown`.
- **The absence signal.** A private LeBonCoin listing that does not appear on any agency portal you scraped in the same postcode is flagged `explicit_particulier_exclusive` — an owner who has not (yet) given a mandate. This signal only exists because the actor runs every portal at once.
- **New-listing delta.** Turn on "only new since last run" and each run returns only properties not seen before, backed by a per-account store. Schedule it and you get a fresh-listings feed.
- **Optional agency enrichment.** Cross-reference agency-listed properties against PagesJaunes to attach agency phone and SIRET.

### How to scrape French real estate data

1. Enter a **location** — a city or department (`Paris`, `Lyon`, `Bordeaux`, `Gironde`).
2. Choose **sale** or **rent**, and optionally a property type.
3. Pick your **portals**. Bien'ici + LeBonCoin is the reliable default. Add SeLoger and Logic-Immo for broader agency coverage.
4. Set a **French residential proxy** (recommended — the portals are anti-bot-protected).
5. Optionally set **seller filter** to `FSBO leads only`, or turn on **only new listings**.
6. Run it. Each row is one deduplicated property with its FSBO classification, price, surface, price per m², location, and per-portal source links.

Schedule the actor with "only new since last run" enabled to receive a rolling feed of fresh private-seller leads for your sector.

### Comment scraper les annonces immobilières de particuliers (pige)

France Pige Pro fait la **pige immobilière** automatiquement. Il interroge Bien'ici et LeBonCoin (SeLoger et Logic-Immo en option) pour une ville ou un département, dédoublonne le même bien présent sur plusieurs portails, et distingue les **annonces de particuliers** des **annonces d'agence**.

- **Leads particuliers.** LeBonCoin indique explicitement si le vendeur est un particulier ou un professionnel. Chaque annonce de particulier devient un lead, avec le nom du vendeur et l'indication d'un numéro de téléphone disponible.
- **Le signal d'absence.** Un bien de particulier sur LeBonCoin, absent des portails d'agences dans le même code postal, signale un propriétaire sans mandat — la cible de la pige.
- **Delta des nouvelles annonces.** Activez « uniquement les nouvelles annonces » et planifiez l'acteur pour recevoir un flux quotidien de nouveaux leads.
- **Enrichissement agences.** Croisement facultatif avec PagesJaunes pour récupérer le téléphone et le SIRET de l'agence.

Champs disponibles : type de bien, surface, pièces, prix, prix au m², code postal, ville, note DPE si présente, type de vendeur (particulier / professionnel), et les liens vers chaque portail.

### Portals and reliability (method disclosure)

| Portal | Method | Reliability | Notes |
|---|---|---|---|
| **Bien'ici** | Open JSON API | High | Clean, complete data. The default agency anchor. |
| **LeBonCoin** | Mobile app API | Medium | Richest seller data (explicit private/pro flag, GPS). DataDome-protected — needs a French residential proxy and can intermittently return zero. |
| **SeLoger** | Browser + API interception | Low | Agency-heavy. Heavy anti-bot; often returns sparse rows. Opt-in. |
| **Logic-Immo** | Browser | Low | DataDome slide-CAPTCHA; frequently returns nothing. Opt-in. |

The actor degrades gracefully: if a portal fails, the run continues with the others and records which portals succeeded in the run summary.

### Documented limits

- **FSBO detection depends on LeBonCoin.** It is the only portal with an explicit private-seller flag. If LeBonCoin is blocked on a run (DataDome), the FSBO count reflects that, not a lack of private inventory — the run summary sets `fsboSourceOk: false` and logs a warning. Re-run, or use a fresh French residential proxy.
- **No shared listing ID.** Cross-portal matching is content-based (postcode + type + surface + price), so it is high-precision but not exhaustive. Cross-listing density rises with `maxItemsPerSource`.
- **Location precision.** Only LeBonCoin exposes real GPS. Bien'ici blurs coordinates to the arrondissement, so latitude/longitude is populated from LeBonCoin members only.
- **SeLoger / Logic-Immo are opt-in.** They add agency coverage but currently return sparse or empty rows; they are excluded from the default portal set for data quality.

### Output fields

Each row is one deduplicated property:

- `isFsbo`, `fsboConfidence`, `sellerType` — the FSBO classification
- `isNew`, `firstSeenAt` — the run-over-run delta
- `crossListed`, `portalCount`, `sourcePortals`, `listings[]` — cross-portal presence and per-portal detail
- `priceEur`, `priceMinEur`, `priceMaxEur`, `priceSpreadPct`, `pricePerM2` — pricing
- `surfaceM2`, `rooms`, `bedrooms`, `propertyType` — the property
- `postalCode`, `city`, `department`, `latitude`, `longitude` — location
- `agencyName`, `agencyPhone`, `agencySiret`, `agencyMatchedPagesJaunes` — agency detail (phone/SIRET when enrichment is on)
- `sellerName`, `hasPhone`, `dpeRating` — seller and energy detail

### Example output

```json
{
  "isFsbo": true,
  "fsboConfidence": "explicit_particulier_exclusive",
  "sellerType": "particulier",
  "isNew": true,
  "crossListed": false,
  "sourcePortals": ["leboncoin"],
  "propertyType": "apartment",
  "listingTitle": "Appartement 3 pièces 68 m²",
  "priceEur": 415000,
  "pricePerM2": 6103,
  "surfaceM2": 68,
  "rooms": 3,
  "postalCode": "33000",
  "city": "Bordeaux",
  "latitude": 44.8378,
  "longitude": -0.5792,
  "sellerName": "Julien",
  "hasPhone": true,
  "dpeRating": "D",
  "listings": [
    { "portal": "leboncoin", "url": "https://www.leboncoin.fr/...", "priceEur": 415000, "sellerType": "particulier" }
  ]
}
````

### How cross-portal dedup works

French portals share no common listing identifier, so the same flat on Bien'ici and on LeBonCoin has two unrelated IDs. France Pige Pro matches on the property itself:

1. **Coarse bucket** — same postcode and same normalized property type.
2. **Surface proximity** — within ±2 m² or ±3% (portals routinely report the same flat as 74 vs 75 m²).
3. **Price proximity** — within ±5% (the same property is often relisted at a slightly different asking price per portal).

A property that clears all three is one row with `crossListed: true` and every portal in `sourcePortals`. Listings without a postcode and surface cannot be matched safely and stay as their own row.

### Who uses this

- **Agency prospection teams** running daily pige to reach owners before a competitor signs the mandate.
- **Investors and renovation lead-gen** filtering on FSBO plus DPE rating or price per m².
- **Proptech and market-analysis teams** needing a deduplicated, cross-portal view of local inventory.

### Pricing

Pay per result. You pay for the run start and for each deduplicated property returned; the FSBO leads and any phone found are priced higher because they are the deliverable. See the pricing tab for current rates.

### FAQ

**Which portals cover FSBO best?**
LeBonCoin. French private sellers concentrate there. Keep LeBonCoin selected for any FSBO run.

**Can I get only the private-seller leads?**
Yes. Set seller filter to `FSBO leads only`.

**How do I get a feed of only new listings?**
Turn on "only new listings since last run" and schedule the actor. The per-account store remembers what it has already returned.

**Do I need a proxy?**
Yes, a French residential proxy is strongly recommended. The default input is configured for one.

**Is this legal?**
The actor collects publicly listed advertisements. You are responsible for how you use the leads, including French prospection and GDPR rules.

# Actor input Schema

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

French city or department to search, e.g. 'Paris', 'Lyon', 'Bordeaux', 'Gironde'. Drives all selected portals.

## `transactionType` (type: `string`):

Sale (ventes) or rent (locations).

## `propertyType` (type: `string`):

Restrict to one property type. Leave empty for all types.

## `portals` (type: `array`):

Which French portals to run and deduplicate across. Bien'ici and LeBonCoin are the reliable, data-rich default. SeLoger and Logic-Immo are agency-heavy but anti-bot-fragile and often return sparse or empty rows; add them for broader agency coverage, accepting lower data quality.

## `sellerFilter` (type: `string`):

Return all properties, only FSBO (private-owner) leads, or only agency-listed properties.

## `onlyNew` (type: `boolean`):

Return only properties not seen in a previous run. Backed by a per-account key-value store. Leave off for a full snapshot.

## `onlyWithContact` (type: `boolean`):

Return only properties where a phone contact is exposed (seller phone or, with agency enrichment, an agency phone).

## `enrichAgencies` (type: `boolean`):

Cross-reference agency-listed properties against PagesJaunes to attach agency phone and SIRET. Adds one extra portal run, so runs take longer. Off by default.

## `minPrice` (type: `integer`):

Lower price bound passed to the portals that support it. Leave empty for no minimum.

## `maxPrice` (type: `integer`):

Upper price bound passed to the portals that support it. Leave empty for no maximum.

## `maxItemsPerSource` (type: `integer`):

Cap on listings pulled from each portal before dedup.

## `timeoutPerSourceSecs` (type: `integer`):

How long to wait for each portal run before treating it as failed.

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

Passed through to the child portal scrapers. French residential proxy is strongly recommended (SeLoger, Logic-Immo and LeBonCoin are anti-bot-protected).

## Actor input object example

```json
{
  "location": "Bordeaux",
  "transactionType": "sale",
  "propertyType": "",
  "portals": [
    "bienici",
    "leboncoin"
  ],
  "sellerFilter": "all",
  "onlyNew": false,
  "onlyWithContact": false,
  "enrichAgencies": false,
  "maxItemsPerSource": 15,
  "timeoutPerSourceSecs": 150,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "FR"
  }
}
```

# 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 = {
    "location": "Paris",
    "transactionType": "sale",
    "portals": [
        "bienici",
        "leboncoin"
    ],
    "sellerFilter": "all",
    "maxItemsPerSource": 15,
    "timeoutPerSourceSecs": 150,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "FR"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("studio-amba/france-pige-pro").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 = {
    "location": "Paris",
    "transactionType": "sale",
    "portals": [
        "bienici",
        "leboncoin",
    ],
    "sellerFilter": "all",
    "maxItemsPerSource": 15,
    "timeoutPerSourceSecs": 150,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "FR",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("studio-amba/france-pige-pro").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 '{
  "location": "Paris",
  "transactionType": "sale",
  "portals": [
    "bienici",
    "leboncoin"
  ],
  "sellerFilter": "all",
  "maxItemsPerSource": 15,
  "timeoutPerSourceSecs": 150,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "FR"
  }
}' |
apify call studio-amba/france-pige-pro --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=studio-amba/france-pige-pro",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "France Pige Pro — FSBO Real Estate Leads Across 4 Portals",
        "description": "Find FSBO (private-owner) property leads in France. Runs SeLoger, Bien'ici, Logic-Immo and LeBonCoin, dedupes each property across portals by a postcode + surface + price fingerprint, and flags every result private-seller or agency-listed. New-listing delta and optional agency enrichment.",
        "version": "0.1",
        "x-build-id": "RKJxVZE7j1kOXee92"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/studio-amba~france-pige-pro/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-studio-amba-france-pige-pro",
                "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/studio-amba~france-pige-pro/runs": {
            "post": {
                "operationId": "runs-sync-studio-amba-france-pige-pro",
                "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/studio-amba~france-pige-pro/run-sync": {
            "post": {
                "operationId": "run-sync-studio-amba-france-pige-pro",
                "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": [
                    "location"
                ],
                "properties": {
                    "location": {
                        "title": "Location (city or department)",
                        "type": "string",
                        "description": "French city or department to search, e.g. 'Paris', 'Lyon', 'Bordeaux', 'Gironde'. Drives all selected portals."
                    },
                    "transactionType": {
                        "title": "Transaction",
                        "enum": [
                            "sale",
                            "rent"
                        ],
                        "type": "string",
                        "description": "Sale (ventes) or rent (locations).",
                        "default": "sale"
                    },
                    "propertyType": {
                        "title": "Property type (optional)",
                        "enum": [
                            "",
                            "apartment",
                            "house",
                            "land",
                            "parking",
                            "commercial"
                        ],
                        "type": "string",
                        "description": "Restrict to one property type. Leave empty for all types.",
                        "default": ""
                    },
                    "portals": {
                        "title": "Portals",
                        "type": "array",
                        "description": "Which French portals to run and deduplicate across. Bien'ici and LeBonCoin are the reliable, data-rich default. SeLoger and Logic-Immo are agency-heavy but anti-bot-fragile and often return sparse or empty rows; add them for broader agency coverage, accepting lower data quality.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "bienici",
                                "leboncoin",
                                "seloger",
                                "logicimmo"
                            ],
                            "enumTitles": [
                                "Bien'ici",
                                "LeBonCoin",
                                "SeLoger",
                                "Logic-Immo"
                            ]
                        },
                        "default": [
                            "bienici",
                            "leboncoin"
                        ]
                    },
                    "sellerFilter": {
                        "title": "Seller filter",
                        "enum": [
                            "all",
                            "fsbo_only",
                            "agency_only"
                        ],
                        "type": "string",
                        "description": "Return all properties, only FSBO (private-owner) leads, or only agency-listed properties.",
                        "default": "all"
                    },
                    "onlyNew": {
                        "title": "Only new listings since last run",
                        "type": "boolean",
                        "description": "Return only properties not seen in a previous run. Backed by a per-account key-value store. Leave off for a full snapshot.",
                        "default": false
                    },
                    "onlyWithContact": {
                        "title": "Only listings with a contact",
                        "type": "boolean",
                        "description": "Return only properties where a phone contact is exposed (seller phone or, with agency enrichment, an agency phone).",
                        "default": false
                    },
                    "enrichAgencies": {
                        "title": "Enrich agencies via PagesJaunes",
                        "type": "boolean",
                        "description": "Cross-reference agency-listed properties against PagesJaunes to attach agency phone and SIRET. Adds one extra portal run, so runs take longer. Off by default.",
                        "default": false
                    },
                    "minPrice": {
                        "title": "Min price (EUR)",
                        "type": "integer",
                        "description": "Lower price bound passed to the portals that support it. Leave empty for no minimum."
                    },
                    "maxPrice": {
                        "title": "Max price (EUR)",
                        "type": "integer",
                        "description": "Upper price bound passed to the portals that support it. Leave empty for no maximum."
                    },
                    "maxItemsPerSource": {
                        "title": "Max items per portal",
                        "type": "integer",
                        "description": "Cap on listings pulled from each portal before dedup.",
                        "default": 40
                    },
                    "timeoutPerSourceSecs": {
                        "title": "Per-portal timeout (seconds)",
                        "type": "integer",
                        "description": "How long to wait for each portal run before treating it as failed.",
                        "default": 150
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Passed through to the child portal scrapers. French residential proxy is strongly recommended (SeLoger, Logic-Immo and LeBonCoin are anti-bot-protected).",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "apifyProxyCountry": "FR"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```