# SeLoger Universal Scraper (`scrapifier/seloger-universal-scraper`) Actor

⚡ Extract unlimited SeLoger listings in seconds! Drop your search URL and get rich, structured real estate data — price, surface, rooms, location, DPE & more. Perfect for market analysis, investment scouting, price benchmarking or lead generation. Automate the French property market & stay ahead! 🏡

- **URL**: https://apify.com/scrapifier/seloger-universal-scraper.md
- **Developed by:** [Scrapifier](https://apify.com/scrapifier) (community)
- **Categories:** Real estate, Lead generation, Integrations
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $0.96 / 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.

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

## 🏠 SeLoger Scraper

A simple tool to extract SeLoger listings and turn France's leading real-estate
portal into structured, usable data.

Stop scrolling and copy-pasting. Collect thousands of listings automatically — with
the **full content of each ad** — filter by your exact criteria, and export to JSON,
CSV or Excel for analysis.

### 🎯 Use cases

This tool can be used for: real-estate analysis, price monitoring, deal hunting,
investment research, competitive watch, lead generation, market research, etc.

---

### 🚀 Quick start

You have **two ways** to tell the scraper what to collect:

**Option A — Use the simple filters** (recommended, no URL needed)
1. Pick **rent or buy**, type a **city** (e.g. `Paris 11`, `Lyon`, `75011`)
2. Optionally set price, surface, rooms, property type
3. Run

**Option B — Paste a SeLoger URL** (advanced)
1. Run a search on SeLoger.com
2. Copy the URL **from your browser's address bar** (it looks like
   `https://www.seloger.com/classified-search?distributionTypes=Rent&estateTypes=Apartment&locations=...`)
3. Paste it into **Search URLs** and run (the older `list.htm?...` URLs work too)

> Use **either** filters **or** a URL. If you fill both, the URL wins.

No technical knowledge required.

---

#### Example Input — by filters (Option A)

```json
{
  "transaction": "rent",
  "locations": ["Paris 11"],
  "property_types": ["apartment"],
  "price_max": 2000,
  "rooms_min": 2,
  "max_pages": 10,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"],
    "apifyProxyCountry": "FR"
  }
}
````

#### Example Input — by URL (Option B)

```json
{
  "urls_list": [
    "https://www.seloger.com/classified-search?distributionTypes=Rent&estateTypes=Apartment,House&locations=AD08FR31096"
  ],
  "max_pages": 10,
  "fetch_details": true,
  "concurrency": 8,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"],
    "apifyProxyCountry": "FR"
  }
}
```

***

#### Example Output

```json
{
  "id": "24LD1P1D4JBQ",
  "legacy_id": 211815093,
  "url": "https://www.seloger.com/annonces/locations/appartement/paris-18eme-75/.../211815093.htm",
  "title": "Appartement à louer",
  "headline": "1 chambre à Montmartre",
  "description": "Splendide appartement rénové et meublé situé Rue Lamarck, dans le quartier de Montmartre...",
  "distribution_type": "RENT",
  "property_type": "APARTMENT",
  "rooms": 2,
  "bedrooms": 1,
  "surface": 55,
  "floor": "4/6",
  "epc": "F",
  "prices": {
    "Loyer charges comprises": "2 895 €/mois",
    "Coûts supplémentaires": "480 €/mois"
  },
  "city": "Paris 18ème arrondissement",
  "district": "Grandes Carrières-Clichy",
  "zip_code": "75018",
  "lat": 48.8907,
  "lng": 2.334,
  "transport": [{ "type": "METRO", "lines": ["12", "13"] }],
  "features": [{ "icon": "furnished", "value": "Meublé" }],
  "photos": ["https://mms.seloger.com/.../photo-1.jpg", "..."],
  "contact_name": "UKIO FRANCE",
  "contact_phones": ["+33(0)757902019"],
  "is_exclusive": true,
  "has_3d_visit": true,
  "scraped_at": "2026-06-21 15:00:00",
  "search_url": "https://www.seloger.com/list.htm?projects=1&types=1,2&..."
}
```

***

### ✨ Features

- **Rich data out of the box**: each listing already comes with description, photos,
  price, surface, rooms, DPE, transport and the **agency phone** — no extra cost
- **Two ways to search**: just type a city and pick filters (rent/buy, type, price,
  surface, rooms…), **or** paste a real SeLoger URL
- **Optional full detail**: turn on `fetch_details` for every photo, the full feature
  list and exact GPS (slower and more expensive — see below)
- **Fast & parallel**, **multiple searches** per run
- **No login, no cookie**: a residential FR proxy is enough
- **Formats**: JSON, CSV, or Excel

***

### 💸 Keep the cost low

- **Leave `fetch_details` OFF** (the default). The search results already include the
  description, photos, phone and key facts. Turning it on fetches one heavy page **per
  listing** through the proxy — that's the main cost driver.
- **Use `max_pages`** to cap volume (25 listings/page). `0` = up to ~2,500 listings.
- Lower **`concurrency`** if you don't need speed. The actor runs on **512 MB** by default.

***

### ⚙️ Inputs at a glance

| Input | What it does |
|---|---|
| `transaction` | `rent` or `buy` (Option A) |
| `locations` | City / postal code, e.g. `Paris 11`, `Lyon`, `75011` (Option A) |
| `property_types` | `apartment` and/or `house` (Option A) |
| `price_min` / `price_max` | Price range in € (Option A) |
| `surface_min` / `surface_max` | Surface range in m² (Option A) |
| `rooms_min` / `bedrooms_min` | Minimum rooms / bedrooms (Option A) |
| `urls_list` | One or more SeLoger search URLs (Option B, advanced) |
| `split_intervals` | Auto-split by price to pass the ~2500 cap (default **ON**) |
| `max_pages` | Pages per search/interval, 25 each (`0` = all) |
| `fetch_details` | Open each listing's page for full detail (default **OFF**, costs more) |
| `concurrency` | Simultaneous requests (default 8) |
| `proxyConfiguration` | Apify proxy (Residential FR recommended) |

***

### ⁉️ FAQ

- **Do I need a SeLoger account or cookie?** No. Just enable a **France residential
  proxy** (preset by default) and run.
- **Filters or URL?** Use the **filters** (Option A) — just a city is required. Or paste a
  SeLoger URL (Option B). If you fill both, the URL wins.
- **More than 2,500 results?** Handled automatically: when a search exceeds SeLoger's
  \~2,500 cap, the actor splits it into price intervals (each under the cap) and scrapes
  them all. Keep `split_intervals` ON and set `max_pages: 0` to get everything.
- **Big run taking long?** Lots of listings means lots of pages — data is saved to the
  dataset as it goes, so even a timeout keeps everything scraped so far. The default run
  timeout is 4 hours (raise it for very large runs).
- **Want it faster / lighter?** Turn off `fetch_details` (the search results already include
  a description), or raise `concurrency`.
- **Some items have a `detail_error`?** A few listings can't return a full detail page:
  ones SeLoger has **already deleted** (still shown in results), or listings hosted on a
  **partner site** (e.g. bellesdemeures.com). For those you still get the search-result
  summary (price, surface, rooms, location, photos…).
- **Legal**: public data only. Respect SeLoger's Terms of Service and GDPR.
- **Freshness**: data is collected live at runtime.
- **Automation**: integrates with the Apify API, scheduler, and your workflows.

***

### 🚀 Ready?

Open the **Input** tab → paste your URL(s) → **Run** → get your data in **Output**.

### 🆘 Issues

If you have any questions or encounter any issues, please kindly post them in the
**Issues** tab — I'll be happy to help and respond as soon as possible! 😊

# Actor input Schema

## `transaction` (type: `string`):

Rent or buy.

## `locations` (type: `array`):

One or more cities, arrondissements or postal codes, e.g. "Paris 11", "Lyon", "75011", "Bordeaux". Each is resolved automatically.

## `property_types` (type: `array`):

Apartment and/or house. Leave empty for both.

## `price_min` (type: `integer`):

Minimum price (monthly rent or sale price, in €).

## `price_max` (type: `integer`):

Maximum price (monthly rent or sale price, in €).

## `surface_min` (type: `integer`):

Minimum living surface in m².

## `surface_max` (type: `integer`):

Maximum living surface in m².

## `rooms_min` (type: `integer`):

Minimum number of rooms (5 = 5 and more).

## `bedrooms_min` (type: `integer`):

Minimum number of bedrooms (5 = 5 and more).

## `urls_list` (type: `array`):

Advanced: instead of the filters above, do a search on SeLoger.com and paste the URL from your browser's address bar (e.g. https://www.seloger.com/classified-search?distributionTypes=Buy\&estateTypes=House,Apartment\&locations=AD08FR31096). The older list.htm?... URLs also work. If set, URLs take precedence over the filters above.

## `max_pages` (type: `integer`):

Maximum number of pages to scrape per search (25 listings/page). Set 0 to scrape all reachable pages. SeLoger caps a search at ~2500 results (100 pages); narrow your filters to go beyond. Big runs are slower — raise the run timeout accordingly.

## `split_intervals` (type: `boolean`):

ON by default. SeLoger caps a single search at ~2500 results. When a search has more, the actor automatically splits it into price intervals (each under the cap) and scrapes them all, so you get the full set. Uses `max_pages` per interval — set `max_pages: 0` to get everything.

## `fetch_details` (type: `boolean`):

OFF by default to keep runs cheap. The search results already include description, photos, price, surface, rooms, DPE, transport and the agency phone. Turn this ON only if you also need every photo, the full feature list and exact GPS — it opens each listing's page (one extra heavy request per listing through the proxy), which makes the run much slower and more expensive.

## `concurrency` (type: `integer`):

Maximum number of simultaneous requests. Pages and detail pages are fetched in parallel up to this limit. Higher = faster but more aggressive (use good residential proxies).

## `delay_between_pages` (type: `number`):

Wait time between requests (politeness). 0 uses the library default jitter.

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

SeLoger is protected by Datadome. Residential proxies in France are strongly recommended — a clean residential IP lets the request through without any cookie.

## Actor input object example

```json
{
  "transaction": "rent",
  "locations": [
    "Paris 11"
  ],
  "property_types": [
    "apartment"
  ],
  "max_pages": 10,
  "split_intervals": true,
  "fetch_details": false,
  "concurrency": 8,
  "delay_between_pages": 0,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "FR"
  }
}
```

# Actor output Schema

## `listings` (type: `string`):

All SeLoger listings extracted by this run.

# 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 = {
    "transaction": "rent",
    "locations": [
        "Paris 11"
    ],
    "property_types": [
        "apartment"
    ],
    "max_pages": 10,
    "split_intervals": true,
    "fetch_details": false,
    "concurrency": 8,
    "delay_between_pages": 0,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "FR"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapifier/seloger-universal-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 = {
    "transaction": "rent",
    "locations": ["Paris 11"],
    "property_types": ["apartment"],
    "max_pages": 10,
    "split_intervals": True,
    "fetch_details": False,
    "concurrency": 8,
    "delay_between_pages": 0,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "FR",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapifier/seloger-universal-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 '{
  "transaction": "rent",
  "locations": [
    "Paris 11"
  ],
  "property_types": [
    "apartment"
  ],
  "max_pages": 10,
  "split_intervals": true,
  "fetch_details": false,
  "concurrency": 8,
  "delay_between_pages": 0,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "FR"
  }
}' |
apify call scrapifier/seloger-universal-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "SeLoger Universal Scraper",
        "description": "⚡ Extract unlimited SeLoger listings in seconds! Drop your search URL and get rich, structured real estate data — price, surface, rooms, location, DPE & more. Perfect for market analysis, investment scouting, price benchmarking or lead generation. Automate the French property market & stay ahead! 🏡",
        "version": "0.0",
        "x-build-id": "YfXIfOt4S7jGEZwc3"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapifier~seloger-universal-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapifier-seloger-universal-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/scrapifier~seloger-universal-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapifier-seloger-universal-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/scrapifier~seloger-universal-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapifier-seloger-universal-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "transaction": {
                        "title": "Transaction",
                        "enum": [
                            "rent",
                            "buy"
                        ],
                        "type": "string",
                        "description": "Rent or buy.",
                        "default": "rent"
                    },
                    "locations": {
                        "title": "Locations (city / postal code)",
                        "type": "array",
                        "description": "One or more cities, arrondissements or postal codes, e.g. \"Paris 11\", \"Lyon\", \"75011\", \"Bordeaux\". Each is resolved automatically.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "property_types": {
                        "title": "Property types",
                        "type": "array",
                        "description": "Apartment and/or house. Leave empty for both.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "apartment",
                                "house"
                            ],
                            "enumTitles": [
                                "Apartment",
                                "House"
                            ]
                        }
                    },
                    "price_min": {
                        "title": "Min price (€)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum price (monthly rent or sale price, in €)."
                    },
                    "price_max": {
                        "title": "Max price (€)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum price (monthly rent or sale price, in €)."
                    },
                    "surface_min": {
                        "title": "Min surface (m²)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum living surface in m²."
                    },
                    "surface_max": {
                        "title": "Max surface (m²)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum living surface in m²."
                    },
                    "rooms_min": {
                        "title": "Min rooms",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Minimum number of rooms (5 = 5 and more)."
                    },
                    "bedrooms_min": {
                        "title": "Min bedrooms",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Minimum number of bedrooms (5 = 5 and more)."
                    },
                    "urls_list": {
                        "title": "Search URLs",
                        "type": "array",
                        "description": "Advanced: instead of the filters above, do a search on SeLoger.com and paste the URL from your browser's address bar (e.g. https://www.seloger.com/classified-search?distributionTypes=Buy&estateTypes=House,Apartment&locations=AD08FR31096). The older list.htm?... URLs also work. If set, URLs take precedence over the filters above.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "max_pages": {
                        "title": "Max pages",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of pages to scrape per search (25 listings/page). Set 0 to scrape all reachable pages. SeLoger caps a search at ~2500 results (100 pages); narrow your filters to go beyond. Big runs are slower — raise the run timeout accordingly.",
                        "default": 10
                    },
                    "split_intervals": {
                        "title": "Get more than 2500 results (split by price)",
                        "type": "boolean",
                        "description": "ON by default. SeLoger caps a single search at ~2500 results. When a search has more, the actor automatically splits it into price intervals (each under the cap) and scrapes them all, so you get the full set. Uses `max_pages` per interval — set `max_pages: 0` to get everything.",
                        "default": true
                    },
                    "fetch_details": {
                        "title": "Fetch full listing details (costs more)",
                        "type": "boolean",
                        "description": "OFF by default to keep runs cheap. The search results already include description, photos, price, surface, rooms, DPE, transport and the agency phone. Turn this ON only if you also need every photo, the full feature list and exact GPS — it opens each listing's page (one extra heavy request per listing through the proxy), which makes the run much slower and more expensive.",
                        "default": false
                    },
                    "concurrency": {
                        "title": "Concurrency",
                        "minimum": 1,
                        "maximum": 32,
                        "type": "integer",
                        "description": "Maximum number of simultaneous requests. Pages and detail pages are fetched in parallel up to this limit. Higher = faster but more aggressive (use good residential proxies).",
                        "default": 8
                    },
                    "delay_between_pages": {
                        "title": "Delay between requests (seconds)",
                        "minimum": 0,
                        "maximum": 10,
                        "type": "number",
                        "description": "Wait time between requests (politeness). 0 uses the library default jitter.",
                        "default": 0
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "SeLoger is protected by Datadome. Residential proxies in France are strongly recommended — a clean residential IP lets the request through without any cookie."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
