# Booli Property Search Scraper (`stealth_mode/booli-property-search-scraper`) Actor

Scrape detailed property listings from Booli.se with one click. Collect prices, locations, images, agency info, and 30+ fields per property — perfect for real estate analysts, investors, developers, and market researchers tracking the Swedish housing market.

- **URL**: https://apify.com/stealth\_mode/booli-property-search-scraper.md
- **Developed by:** [Stealth mode](https://apify.com/stealth_mode) (community)
- **Categories:** Automation, Developer tools, Real estate
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.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.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

## Booli Property Search Scraper: Extract Swedish Real Estate Data at Scale

---

### What Is Booli.se?

Booli.se is Sweden's leading property search platform, hosting thousands of residential listings across apartments, villas, and new construction projects. It serves real estate professionals, investors, and homebuyers seeking market transparency. Booli consolidates listings from multiple agencies and developers, making it a rich source for property market intelligence — but manually collecting and structuring this data is laborious and error-prone.

The **Booli Property Search Scraper** automates data extraction, transforming unstructured listings into clean, actionable datasets in minutes.

---

### Overview

The **Booli Property Search Scraper** extracts comprehensive property records from Booli.se search results pages, capturing 30+ data points per listing. It is built for:

- **Real estate investors** analyzing market trends and pricing patterns
- **Market researchers** studying Swedish housing supply and demand
- **Property developers** monitoring competitor projects and launches
- **Data analysts** building real estate intelligence platforms
- **Agencies** aggregating market data for client reports

The scraper handles search result pagination, manages proxy rotation to prevent blocking, and gracefully continues on failed URLs — ideal for large-scale collection campaigns.

---

### Input Format

The scraper accepts a JSON configuration object defining which property listings to extract and how to handle the scraping process:

```json
{
  "urls": [
    "https://www.booli.se/sok/till-salu/?page=2"
  ],
  "ignore_url_failures": true,
  "max_items_per_url": 200
}
````

#### Input Parameters Explained

| Parameter | Type | Description | Example |
|---|---|---|---|
| `urls` | Array | Booli search result page URLs to scrape. Each URL can return up to `max_items_per_url` listings. | `["https://www.booli.se/sok/till-salu/?page=2"]` |
| `ignore_url_failures` | Boolean | If `true`, the scraper continues running even if a URL fails. If `false`, the entire run stops on first error. | `true` |
| `max_items_per_url` | Integer | Maximum number of property listings to extract per URL. Set based on your data needs and rate-limiting concerns. | `200` |

#### Input Tips

- **Search pages:** Use filtered Booli search URLs (e.g., by region, price range, property type) to target specific subsets of the market.
- **Pagination:** Include multiple page URLs to collect larger datasets. For example:
  - `https://www.booli.se/sok/till-salu/?page=1`
  - `https://www.booli.se/sok/till-salu/?page=2`
  - `https://www.booli.se/sok/till-salu/?page=3`
- **Limits:** Set `max_items_per_url` conservatively (50–200) to avoid timeout or server load issues on large result sets.

***

### Output Format

#### Example Output Record

```json
{
  "id": "6120847",
  "booli_id": "6120847",
  "amenities": [
    {
      "__typename": "Amenity",
      "key": "balcony",
      "label": "Balkong"
    },
    {
      "__typename": "Amenity",
      "key": "fireplace",
      "label": "Eldstad"
    }
  ],
  "blocked_images": false,
  "descriptive_area_name": "Motala",
  "display_attributes": {
    "__typename": "DisplayAttributes",
    "screen_reader_label": "4 rum radhus på Akasialiden 20G Motala, Motala kommun",
    "data_points": [
      {
        "__typename": "DataPoint",
        "value": {
          "__typename": "DisplayText",
          "plain_text": "133 + 35 m²"
        },
        "screen_reader_label": "133 + 35 kvadratmeter"
      },
      {
        "__typename": "DataPoint",
        "value": {
          "__typename": "DisplayText",
          "plain_text": "4 rum"
        },
        "screen_reader_label": "4 rum"
      },
      {
        "__typename": "DataPoint",
        "value": {
          "__typename": "DisplayText",
          "plain_text": "205 m² tomt"
        },
        "screen_reader_label": "205 kvadratmeter tomt"
      }
    ]
  },
  "location": {
    "__typename": "Location",
    "region": {
      "__typename": "Region",
      "municipality_name": "Motala"
    }
  },
  "published": "2026-06-08 16:50:07",
  "list_price": null,
  "list_price_percentage_diff": null,
  "list_sqm_price": null,
  "latitude": 58.53867997,
  "longitude": 15.04479569,
  "days_active": 0,
  "primary_image": null,
  "object_type": "Radhus",
  "estimate": {
    "__typename": "Estimate",
    "price": {
      "__typename": "FormattedValue",
      "value": "2 650 000",
      "unit": "kr",
      "raw": 2650000,
      "formatted": "2 650 000 kr"
    }
  },
  "street_address": "Akasialiden 20G",
  "url": "/bostad/2506673",
  "is_new_construction": false,
  "bidding_open": 1,
  "upcoming_sale": false,
  "tenure_form": "Äganderätt",
  "agency": null,
  "next_showing": null,
  "images": [
    {
      "__typename": "Image",
      "id": "53363041",
      "alt": "Exteriörbild",
      "width": 1920,
      "height": 1280,
      "primary_label": "exterior"
    },
    {
      "__typename": "Image",
      "id": "53363043",
      "width": 1920,
      "height": 1280,
      "primary_label": "fireplace",
      "alt": "Eldstad"
    },
    {
      "__typename": "Image",
      "id": "53363045",
      "width": 1920,
      "height": 1280,
      "primary_label": "kitchen/dining_room",
      "alt": "Kök eller matrum"
    },
    {
      "__typename": "Image",
      "id": "53363046",
      "width": 1920,
      "height": 1280,
      "primary_label": "kitchen/dining_room",
      "alt": "Kök eller matrum"
    },
    {
      "__typename": "Image",
      "id": "53363049",
      "width": 1920,
      "height": 1280,
      "primary_label": "kitchen/dining_room",
      "alt": "Kök eller matrum"
    }
  ],
  "booli_url": null,
  "phase": null,
  "subtitle": null,
  "name": null,
  "list_price_range": null,
  "occupancy": null,
  "project_images": null,
  "developer": null,
  "created": null,
  "rooms_list": null,
  "featured": null,
  "sold_price": null,
  "sold_price_absolute_diff": null,
  "sold_price_percentage_diff": null,
  "sold_price_type": null,
  "from_url": "https://www.booli.se/sok/till-salu"
}
```

Each scraped property returns a rich dataset with 30+ fields covering identification, pricing, location, imagery, tenure, and market activity:

#### Core Property Information

| Field | Meaning |
|---|---|
| `ID` | Internal Booli unique identifier for the property listing |
| `Booli ID` | Alternative Booli system ID (may differ from ID field) |
| `Name` | Official property name or project title |
| `Subtitle` | Secondary descriptive text (e.g., "Renovated 1970s villa") |
| `Street Address` | Full street address of the property |
| `Descriptive Area Name` | Neighborhood or district name (e.g., "Södermalm, Stockholm") |
| `Location` | Geographic location metadata (coordinates, region codes) |
| `URL` | Direct link to the property listing on Booli.se |
| `Booli URL` | Alternative canonical URL for the property |

#### Pricing & Valuation

| Field | Meaning |
|---|---|
| `List Price` | Current asking price in SEK (Swedish Kronor) |
| `List Price Range` | Price range if exact figure not set (e.g., "5,000,000–6,000,000 SEK") |
| `List Price Percentage Diff` | Percentage difference between asking price and Booli estimate |
| `List SQM Price` | Price per square meter (SEK/m²) — useful for market comparisons |
| `Estimate` | Booli's internal valuation estimate based on comparable sales |
| `Sold Price` | Final sale price (once property is sold) |
| `Sold Price Type` | Type of sale (e.g., private, auction, estate) |
| `Sold Price Absolute Diff` | Absolute difference between list price and sold price (SEK) |
| `Sold Price Percentage Diff` | Percentage difference between list price and sold price |

#### Property Characteristics

| Field | Meaning |
|---|---|
| `Object Type` | Property category (e.g., "Apartment", "Villa", "Townhouse") |
| `Rooms List` | Array or count of rooms (bedrooms, bathrooms) |
| `Occupancy` | Living space, size, or occupancy type |
| `Is New Construction` | Boolean flag: `true` if the property is a new build |
| `Tenure Form` | Type of ownership (e.g., "Bostadsrätt" \[cooperative], "Äganderätt" \[freehold]) |
| `Phase` | Development phase if part of a new construction project |
| `Developer` | Name of the developer or builder (for new construction) |

#### Market Activity & Exposure

| Field | Meaning |
|---|---|
| `Published` | Date the listing was published on Booli |
| `Created` | Date the property record was created in the system |
| `Days Active` | Number of days the listing has been active |
| `Bidding Open` | Boolean: whether active bidding/offers are being accepted |
| `Upcoming Sale` | Boolean: indicates a scheduled or upcoming auction/sale |
| `Next Showing` | Scheduled viewing date/time (if available) |
| `Featured` | Boolean: whether the listing is promoted/featured on Booli |

#### Imagery & Media

| Field | Meaning |
|---|---|
| `Primary Image` | URL of the main listing photo |
| `Images` | Array of all property images (exterior, interior, landscaping) |
| `Blocked Images` | Count or list of images that failed to load or were removed |
| `Project Images` | Images specific to new construction projects |

#### Amenities & Features

| Field | Meaning |
|---|---|
| `Amenities` | List of key features (e.g., "Balcony", "Garden", "Parking", "Energy-efficient") |
| `Display Attributes` | Structured attributes shown in search results and detail views |

#### Sales & Agency Information

| Field | Meaning |
|---|---|
| `Agency` | Real estate agency managing the sale (name, contact info) |
| `Latitude` | Geographic latitude coordinate (decimal degrees) |
| `Longitude` | Geographic longitude coordinate (decimal degrees) |
-------------------------------------------------------------------

### How to Use

#### Step 1: Identify Search URLs

Visit Booli.se and create search filters matching your needs (region, price range, property type). Copy the resulting page URLs.

**Examples:**

- `https://www.booli.se/sok/till-salu/?page=1` — All properties for sale
- `https://www.booli.se/sok/stockholm/till-salu/?page=1` — Stockholm only
- `https://www.booli.se/sok/stockholm/till-salu/?min=4000000&max=6000000&page=1` — Stockholm, 4–6M SEK

#### Step 2: Configure Input

Paste your URLs into the `urls` array. Set `max_items_per_url` (e.g., 100–200 for balanced coverage and speed).

#### Step 3: Run the Scraper

Initiate the actor. The scraper will:

- Navigate to each URL
- Extract property records from search results
- Collect all 30+ fields per listing
- Skip failed URLs if `ignore_url_failures: true`
- Return structured JSON data

#### Step 4: Export & Analyze

Download results as JSON, CSV, or Excel. Load into your analysis tool (spreadsheet, database, BI platform).

**Best Practices:**

- Test with a single page first to verify output format
- Use `ignore_url_failures: true` for production runs
- Space out large scraping jobs to avoid rate limiting
- Cross-reference with Booli's `Estimate` field to identify underpriced listings

***

### Use Cases & Business Value

- **Investment analysis:** Identify market gaps, underpriced properties, and emerging neighborhoods
- **Market intelligence:** Track price trends, days-on-market, and supply dynamics by region
- **Competitive monitoring:** Monitor competitor listings, pricing strategies, and market share
- **Data enrichment:** Append property data to your CRM, database, or investment platform
- **Academic research:** Analyze Swedish housing affordability, market efficiency, and regional variation

Real estate professionals using the Booli Property Search Scraper gain competitive advantage through data-driven decision-making, reducing manual research time from hours to minutes.

***

### Conclusion

The **Booli Property Search Scraper** delivers Swedish property market data in structured, actionable format. With 30+ fields per listing and flexible filtering, it empowers investors, analysts, and developers to unlock insights from Booli's comprehensive marketplace. Start scraping today and transform raw listings into strategic advantage.

# Actor input Schema

## `urls` (type: `array`):

Add the URLs of the property list urls you want to scrape. You can paste URLs one by one, or use the Bulk edit section to add a prepared list.

## `ignore_url_failures` (type: `boolean`):

If true, the scraper will continue running even if some URLs fail to be scraped.

## `max_items_per_url` (type: `integer`):

The maximum number of items to scrape per URL.

## `proxy` (type: `object`):

Select proxies to be used by your scraper.

## Actor input object example

```json
{
  "urls": [
    "https://www.booli.se/sok/till-salu/?page=2"
  ],
  "ignore_url_failures": true,
  "max_items_per_url": 20,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "SE"
  }
}
```

# 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 = {
    "urls": [
        "https://www.booli.se/sok/till-salu/?page=2"
    ],
    "ignore_url_failures": true,
    "max_items_per_url": 20,
    "proxy": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "SE"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("stealth_mode/booli-property-search-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 = {
    "urls": ["https://www.booli.se/sok/till-salu/?page=2"],
    "ignore_url_failures": True,
    "max_items_per_url": 20,
    "proxy": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "SE",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("stealth_mode/booli-property-search-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 '{
  "urls": [
    "https://www.booli.se/sok/till-salu/?page=2"
  ],
  "ignore_url_failures": true,
  "max_items_per_url": 20,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "SE"
  }
}' |
apify call stealth_mode/booli-property-search-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Booli Property Search Scraper",
        "description": "Scrape detailed property listings from Booli.se with one click. Collect prices, locations, images, agency info, and 30+ fields per property — perfect for real estate analysts, investors, developers, and market researchers tracking the Swedish housing market.",
        "version": "0.0",
        "x-build-id": "m8SDXzS8Zs8hBpmqY"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/stealth_mode~booli-property-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-stealth_mode-booli-property-search-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/stealth_mode~booli-property-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-stealth_mode-booli-property-search-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/stealth_mode~booli-property-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-stealth_mode-booli-property-search-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": {
                    "urls": {
                        "title": "URLs of the property list urls to scrape",
                        "type": "array",
                        "description": "Add the URLs of the property list urls you want to scrape. You can paste URLs one by one, or use the Bulk edit section to add a prepared list.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "ignore_url_failures": {
                        "title": "Continue running even if some URLs fail to be scraped",
                        "type": "boolean",
                        "description": "If true, the scraper will continue running even if some URLs fail to be scraped."
                    },
                    "max_items_per_url": {
                        "title": "Max items per URL",
                        "type": "integer",
                        "description": "The maximum number of items to scrape per URL."
                    },
                    "proxy": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Select proxies to be used by your scraper."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
