# Egyptian Real Estate Scraper (`constructive_calm/egypt-real-estate-scraper`) Actor

Scrapes property listings from Dubizzle, Aqarmap, and PropertyFinder Egypt. Extracts prices, areas, bedrooms, GPS coordinates, payment plans, agent info, and amenities into normalized structured data.

- **URL**: https://apify.com/constructive\_calm/egypt-real-estate-scraper.md
- **Developed by:** [Omar Eldeeb](https://apify.com/constructive_calm) (community)
- **Categories:** Real estate, Developer tools, Agents
- **Stats:** 5 total users, 4 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $5.00 / 1,000 results

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

### What does Egyptian Real Estate Scraper do?

**Egyptian Real Estate Scraper** extracts property listings from the three largest Egyptian real estate platforms — **Dubizzle**, **Aqarmap**, and **PropertyFinder** — into a single, normalized dataset. It captures prices, areas, bedrooms, GPS coordinates, compound names, payment plans, agent contacts, amenities, and more.

Whether you're an investor tracking the Egyptian property market, a real estate agency benchmarking competitors, or a data analyst building market reports, this actor gives you structured data from 600,000+ combined listings across all major platforms.

### Why use Egyptian Real Estate Scraper?

- **Multi-platform coverage** — Scrape Dubizzle (168K+ listings), Aqarmap (450K+ properties), and PropertyFinder (93K+ listings) in a single run
- **Normalized data** — Consistent output schema across all platforms, ready for analysis
- **Rich property data** — Prices, price per sqm, GPS coordinates, compound names, amenities, agent info, payment plans
- **Residential & commercial** — Apartments, villas, studios, duplexes, penthouses, shops, offices, and more
- **Sale & rental** — Track both purchase and rental markets
- **Change detection** — Monitor price changes, new listings, and removed properties between runs
- **Smart fingerprinting** — Detects re-posted listings using GPS, photo hashes, and property fingerprints
- **AI fallback** — Automatic AI-powered extraction when standard methods fail

### What data can this scraper extract?

| Field | Description |
|-------|-------------|
| `priceEGP` | Price in Egyptian Pounds |
| `pricePerSqm` | Calculated price per square meter |
| `areaSqm` | Property area in square meters |
| `bedrooms` / `bathrooms` | Room counts |
| `city` / `district` / `compound` | Full location hierarchy |
| `latitude` / `longitude` | GPS coordinates (PropertyFinder) |
| `amenities` | Pool, gym, security, parking, etc. |
| `sellerName` / `sellerPhone` | Agent contact details |
| `agencyName` / `brokerLicense` | Broker information |
| `downPayment` / `installmentYears` | Payment plan details |
| `isVerified` | Platform verification status |
| `listingDate` | When the listing was posted |
| `hasChanges` / `changes` | Price change tracking |

### How to scrape Egyptian real estate data

1. **Select platforms** — Choose Dubizzle, Aqarmap, PropertyFinder, or all three
2. **Set filters** — Pick location (Cairo, New Cairo, Alexandria, etc.), property type (apartment, villa), and listing type (sale/rent)
3. **Configure limits** — Set max listings per platform and optional price/area filters
4. **Click Start** — The actor scrapes all selected platforms and outputs normalized data
5. **Download results** — Access your data in JSON, CSV, or Excel format from the Output tab

### Output

```json
{
    "sourcePlatform": "propertyfinder",
    "title": "Apartment in Swan Lake Residence",
    "priceEGP": 12425000,
    "pricePerSqm": 96317,
    "areaSqm": 129,
    "bedrooms": 2,
    "bathrooms": 3,
    "city": "Cairo",
    "district": "New Cairo City",
    "compound": "Swan Lake Residence",
    "latitude": 30.0739,
    "longitude": 31.4655,
    "amenities": ["Balcony", "Security", "Shared Pool"],
    "sellerName": "Ahmed Safwat",
    "agencyName": "New Avenue Real Estate",
    "downPayment": 9000000,
    "isVerified": false,
    "listingDate": "2026-04-07T10:02:58Z",
    "extractionConfidence": "high"
}
````

### How much does it cost?

- **$0.01** per actor run start
- **$0.005** per listing extracted

**Example costs:**

- 100 listings from all platforms = **$0.51**
- 1,000 listings for market analysis = **$5.01**
- Monthly monitoring of 500 listings = **$2.51/month**

### How to scrape large datasets (1,000+ listings)

The actor can extract up to **5,000 listings per platform** (15,000 total across all three). Here's how to optimize for large runs:

**Speed by platform:**
| Platform | Speed | 1,000 listings | 5,000 listings |
|----------|-------|----------------|----------------|
| Aqarmap | ~4s/page (20/page) | ~3 min | ~17 min |
| PropertyFinder | ~1s/page (25/page) | ~1 min | ~4 min |
| Dubizzle | ~30s/page (46/page, Playwright) | ~12 min | ~55 min |

**Tips for large runs:**

- Set `maxListingsPerPlatform` up to 5,000 for comprehensive market coverage
- Use **4096 MB memory** for best Playwright performance
- For fastest results, scrape **Aqarmap + PropertyFinder only** (no browser needed)
- Dubizzle paginates automatically through multiple search pages — each page yields ~46 listings
- When using "Both" (sale + rent), the quota splits evenly — set 2x your target per type
- **Cost estimate**: 5,000 listings = ~$25. Monthly monitoring of 1,000 listings = $5/month

**Platform inventory (approximate):**

- Aqarmap: 450K+ properties (108K apartments in Cairo alone)
- PropertyFinder: 93K+ listings (richest data — GPS, amenities, agent info)
- Dubizzle: 168K+ listings (44K apartments in Cairo)

### Tips and advanced options

- **PropertyFinder has the richest data** — GPS coordinates, amenities, and payment plans are available directly from search results without needing to visit individual listings
- **Enable "Enrich with Full Details"** to follow listing URLs for complete data (GPS, agent phone, photos) — slower but much more valuable
- **All filters are enforced in code** — price, area, and bedroom filters are applied after extraction for accuracy, since some platforms ignore URL-based filters
- **Dubizzle requires browser rendering** — it's a JavaScript-rendered site, so runs take longer for Dubizzle compared to Aqarmap/PropertyFinder
- **Schedule monthly runs** with a named dataset to automatically track price changes and new listings
- **Sort options**: Newest first, lowest/highest price, smallest/largest area (Aqarmap supports all; PropertyFinder uses platform defaults)

### FAQ and support

**Is it legal to scrape Egyptian real estate websites?**
Property listings are publicly accessible information intended for buyers and renters. This actor only accesses publicly available data. Always review each platform's Terms of Service.

**Why are some Dubizzle listings missing area/bathrooms?**
Dubizzle titles are marketing text and rarely include area or bathroom counts. Bedrooms, price, and compound name are usually available. Enable "Enrich with Full Details" to visit individual listing pages for complete data.

**Can I track price changes?**
Yes — enable "Detect Listing Changes" and provide a named dataset. The actor uses a 4-layer fingerprinting system (ID, GPS, photo hashes, property fingerprint) to match listings across runs even when IDs change.

**Need help?**
Open an issue in the Issues tab or reach out for a custom solution.

# Actor input Schema

## `platforms` (type: `array`):

Select which Egyptian real estate platforms to scrape. Choose individual platforms or 'All' for comprehensive coverage.

## `listingType` (type: `string`):

Scrape properties for sale, for rent, or both.

## `propertyCategory` (type: `string`):

Residential properties (apartments, villas) or commercial (shops, offices).

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

Filter by specific property type. Leave empty for all types.

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

Filter by Egyptian city or area. Leave empty for all locations.

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

Minimum price in Egyptian Pounds. Filtering is done after extraction for accuracy.

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

Maximum price in Egyptian Pounds. Filtering is done after extraction for accuracy.

## `areaMin` (type: `integer`):

Minimum property area in square meters.

## `areaMax` (type: `integer`):

Maximum property area in square meters.

## `bedrooms` (type: `integer`):

Filter by minimum number of bedrooms.

## `sortBy` (type: `string`):

How to sort listings on platforms that support it.

## `maxListingsPerPlatform` (type: `integer`):

Maximum number of listings to extract from each platform. Set lower for faster runs.

## `enrichListings` (type: `boolean`):

Follow each listing URL to extract full details: GPS coordinates, agent phone, payment plans, amenities, all photos. Slower but much richer data.

## `useAI` (type: `boolean`):

Automatically use AI vision when standard extraction fails. Costs an additional $0.03 per listing where AI is needed.

## `useBrowser` (type: `string`):

Auto uses fast HTTP for Aqarmap/PropertyFinder and browser for Dubizzle. 'Always' renders all pages in browser.

## `detectChanges` (type: `boolean`):

Compare results against a previous run to detect price changes, new listings, and removed listings.

## `datasetName` (type: `string`):

Named dataset for persistent storage. Enables automatic change detection between scheduled runs.

## `webhookUrl` (type: `string`):

URL to POST notifications when price changes or new listings are detected.

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

Maximum concurrent requests. Lower values are gentler on target sites.

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

Proxy settings. Recommended for production use to avoid rate limiting.

## Actor input object example

```json
{
  "platforms": [
    "all"
  ],
  "listingType": "both",
  "propertyCategory": "residential",
  "sortBy": "newest",
  "maxListingsPerPlatform": 100,
  "enrichListings": false,
  "useAI": true,
  "useBrowser": "auto",
  "detectChanges": false,
  "maxConcurrency": 5,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `dataset` (type: `string`):

Dataset containing normalized property listings from all selected platforms

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("constructive_calm/egypt-real-estate-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("constructive_calm/egypt-real-estate-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 '{}' |
apify call constructive_calm/egypt-real-estate-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Egyptian Real Estate Scraper",
        "description": "Scrapes property listings from Dubizzle, Aqarmap, and PropertyFinder Egypt. Extracts prices, areas, bedrooms, GPS coordinates, payment plans, agent info, and amenities into normalized structured data.",
        "version": "1.0",
        "x-build-id": "wZAnhyouqmeFF6BPh"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/constructive_calm~egypt-real-estate-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-constructive_calm-egypt-real-estate-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/constructive_calm~egypt-real-estate-scraper/runs": {
            "post": {
                "operationId": "runs-sync-constructive_calm-egypt-real-estate-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/constructive_calm~egypt-real-estate-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-constructive_calm-egypt-real-estate-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "platforms"
                ],
                "properties": {
                    "platforms": {
                        "title": "Platforms",
                        "type": "array",
                        "description": "Select which Egyptian real estate platforms to scrape. Choose individual platforms or 'All' for comprehensive coverage.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "all",
                                "aqarmap",
                                "propertyfinder",
                                "dubizzle"
                            ],
                            "enumTitles": [
                                "All Platforms",
                                "Aqarmap (450K+ properties)",
                                "PropertyFinder (richest data)",
                                "Dubizzle/OLX (168K+ listings)"
                            ]
                        },
                        "default": [
                            "all"
                        ]
                    },
                    "listingType": {
                        "title": "Listing Type",
                        "enum": [
                            "sale",
                            "rent",
                            "both"
                        ],
                        "type": "string",
                        "description": "Scrape properties for sale, for rent, or both.",
                        "default": "both"
                    },
                    "propertyCategory": {
                        "title": "Property Category",
                        "enum": [
                            "residential",
                            "commercial"
                        ],
                        "type": "string",
                        "description": "Residential properties (apartments, villas) or commercial (shops, offices).",
                        "default": "residential"
                    },
                    "propertyType": {
                        "title": "Property Type",
                        "enum": [
                            "",
                            "apartment",
                            "villa",
                            "studio",
                            "duplex",
                            "penthouse",
                            "townhouse",
                            "chalet",
                            "land",
                            "shop",
                            "office",
                            "commercial"
                        ],
                        "type": "string",
                        "description": "Filter by specific property type. Leave empty for all types."
                    },
                    "location": {
                        "title": "Location",
                        "enum": [
                            "",
                            "cairo",
                            "new-cairo",
                            "6th-of-october",
                            "alexandria",
                            "giza",
                            "hurghada",
                            "north-coast",
                            "sheikh-zayed",
                            "ain-sokhna",
                            "madinaty",
                            "shorouk"
                        ],
                        "type": "string",
                        "description": "Filter by Egyptian city or area. Leave empty for all locations."
                    },
                    "priceMin": {
                        "title": "Minimum Price (EGP)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum price in Egyptian Pounds. Filtering is done after extraction for accuracy."
                    },
                    "priceMax": {
                        "title": "Maximum Price (EGP)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum price in Egyptian Pounds. Filtering is done after extraction for accuracy."
                    },
                    "areaMin": {
                        "title": "Minimum Area (sqm)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum property area in square meters."
                    },
                    "areaMax": {
                        "title": "Maximum Area (sqm)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum property area in square meters."
                    },
                    "bedrooms": {
                        "title": "Bedrooms",
                        "minimum": 0,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Filter by minimum number of bedrooms."
                    },
                    "sortBy": {
                        "title": "Sort By",
                        "enum": [
                            "newest",
                            "price_asc",
                            "price_desc",
                            "area_asc",
                            "area_desc"
                        ],
                        "type": "string",
                        "description": "How to sort listings on platforms that support it.",
                        "default": "newest"
                    },
                    "maxListingsPerPlatform": {
                        "title": "Max Listings per Platform",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of listings to extract from each platform. Set lower for faster runs.",
                        "default": 100
                    },
                    "enrichListings": {
                        "title": "Enrich with Full Details",
                        "type": "boolean",
                        "description": "Follow each listing URL to extract full details: GPS coordinates, agent phone, payment plans, amenities, all photos. Slower but much richer data.",
                        "default": false
                    },
                    "useAI": {
                        "title": "AI-Enhanced Extraction",
                        "type": "boolean",
                        "description": "Automatically use AI vision when standard extraction fails. Costs an additional $0.03 per listing where AI is needed.",
                        "default": true
                    },
                    "useBrowser": {
                        "title": "Browser Rendering Mode",
                        "enum": [
                            "auto",
                            "always",
                            "never"
                        ],
                        "type": "string",
                        "description": "Auto uses fast HTTP for Aqarmap/PropertyFinder and browser for Dubizzle. 'Always' renders all pages in browser.",
                        "default": "auto"
                    },
                    "detectChanges": {
                        "title": "Detect Listing Changes",
                        "type": "boolean",
                        "description": "Compare results against a previous run to detect price changes, new listings, and removed listings.",
                        "default": false
                    },
                    "datasetName": {
                        "title": "Named Dataset",
                        "type": "string",
                        "description": "Named dataset for persistent storage. Enables automatic change detection between scheduled runs."
                    },
                    "webhookUrl": {
                        "title": "Webhook URL for Alerts",
                        "type": "string",
                        "description": "URL to POST notifications when price changes or new listings are detected."
                    },
                    "maxConcurrency": {
                        "title": "Max Concurrency",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Maximum concurrent requests. Lower values are gentler on target sites.",
                        "default": 5
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings. Recommended for production use to avoid rate limiting.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
