# 🏠 Airbnb Images Scraper (`scrapebase/airbnb-images-scraper`) Actor

📸 Scrapes Airbnb room listing pages for structured data and image URLs. Extracts listing title, location, rating, review count, and all image URLs from one or more room URLs. Starts with direct requests for speed; if blocked or rate-limited, automatically switches to Apify Residential proxy and...

- **URL**: https://apify.com/scrapebase/airbnb-images-scraper.md
- **Developed by:** [ScrapeBase](https://apify.com/scrapebase) (community)
- **Categories:** E-commerce, Agents, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$19.99/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period.You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#rental-actors

## 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

### 🏠 Airbnb Images Scraper

The 🏠 Airbnb Images Scraper is a focused Airbnb image scraper that fetches structured metadata and photo URLs directly from Airbnb room pages. It solves the “right-click-save” problem for marketers, developers, data analysts, and researchers by extracting listing titles, locations, ratings, review counts, and all image URLs from one or more provided room links. Built for speed and scale, this Airbnb listing images scraper enables repeatable, bulk workflows like scrape Airbnb listing photos, download Airbnb images, and build an Airbnb images dataset at scale.

### What data / output can you get?

This Airbnb image scraping tool parses the embedded JSON-LD from each Airbnb room page and outputs a clean, structured record per URL. You can export your dataset to JSON, CSV, or Excel from Apify.

| Data type | Description | Example value |
| --- | --- | --- |
| url | The Airbnb room URL processed | https://www.airbnb.com/rooms/782682596976136912 |
| title | Listing title normalized from JSON-LD | "Perfect Getaway" 2 Miles from MIA & 8To UR Cruise |
| location | Address locality with a fixed “Florida, United States” suffix | Hialeah, Florida, United States |
| rating | Average rating as a float (0 if missing) | 4.95 |
| reviews | Total review count as an integer (0 if missing) | 168 |
| images | Array of direct image URLs | ["https://a0.muscache.com/im/pictures/...jpg", "..."] |
| error | Only when a URL fails to fetch/parse; contains a message | Fetch failed: 403 Client Error: Forbidden |

Note:
- The scraper reads JSON-LD from the page source; missing values are normalized to defaults (rating = 0, reviews = 0, images = [], location may show “Unknown, Florida, United States”).
- Apify lets you export the resulting Airbnb images dataset to JSON, CSV, or Excel without extra setup.

### Key features

- ⚡️ Fast direct-fetch architecture
  Uses lightweight direct HTTP requests for speed. If the actor detects a block (403/429/captcha), it automatically switches to Apify Residential proxy and retries.

- 🛡️ Automatic anti-block fallback
  Starts without a proxy; on block or server errors, it mints a Residential proxy URL (with your chosen groups/country) and retries up to 3×, then stays on proxy for subsequent URLs.

- 🧩 Structured JSON-LD extraction
  Extracts key fields from Airbnb’s embedded structured data: url, title, location, rating, reviews, and all image URLs for reliable Airbnb photo extractor workflows.

- 📸 Bulk image URL collection
  Paste multiple room URLs to run an Airbnb photo URL extractor and bulk download Airbnb photos later using your preferred tools or pipelines.

- 💾 Easy dataset export
  Results are stored in an Apify dataset you can export to JSON, CSV, or Excel—ideal for Airbnb media downloader use cases and downstream analytics.

- 🧪 Robust validation & error reporting
  Validates input URLs must start with https://www.airbnb.com/rooms/. Failed items are kept with an error message so you can audit and retry cleanly.

- 👨‍💻 Developer-friendly & API-ready
  Clean, minimal schema makes it simple to integrate with scripts and pipelines (e.g., Airbnb photo scraping Python workflows via Apify API or apify-client).

- 🏗️ Production-ready reliability
  Clear logs, retries on proxy, and a run summary file ensure repeatability for batch runs and automated schedules.

### How to use 🏠 Airbnb Images Scraper - step by step

1. Create or log in to your Apify account.
2. Open the 🏠 Airbnb Images Scraper in the Apify Store.
3. Add input data:
   - Paste one or more Airbnb room URLs into urls (each must start with https://www.airbnb.com/rooms/…).
4. (Optional) Configure proxy:
   - In proxyConfiguration, set apifyProxyGroups (e.g., ["RESIDENTIAL"]) and optionally apifyProxyCountry (e.g., "US"). The actor starts direct and switches to Residential proxy if blocked.
5. Adjust timeout (optional):
   - requestTimeoutSecs controls the per-request HTTP timeout (default 30; allowed range 5–120).
6. Start the run:
   - Click Start. The actor fetches each URL, parses JSON-LD, and stores structured results in the dataset.
7. Export your results:
   - Go to the run’s Dataset and export to JSON, CSV, or Excel for use in your reporting, dashboards, or content pipelines.

Pro Tip:
- For automation, trigger the actor via Apify API and feed it room URLs from your system to build a recurring Airbnb image crawler flow.

### Use cases

| Use case name | Description |
| --- | --- |
| Market research + visual benchmarking | Compare listings by rating, reviews, and captured photos to understand positioning and visual standards in your niche. |
| Host competitor audits | Track competitor titles, ratings, and image sets across multiple properties to refine your own listing presentation. |
| Content curation for marketing | Collect high-resolution image URLs to create mood boards or analyze visual patterns in your target markets. |
| Bulk photo URL extraction | Run an Airbnb photo URL extractor over a list of properties and feed the URLs to your downloader or CDN workflows. |
| API pipeline integration | Pipe records to your data lake; ideal for Airbnb photo scraping Python scripts using Apify’s API and client libraries. |
| Academic/tourism research | Build a lightweight dataset of location, reviews, ratings, and images for trend analysis without heavy crawling. |

### Why choose 🏠 Airbnb Images Scraper?

Purpose-built for precision and reliability, this Airbnb image scraping tool focuses on clean JSON-LD extraction and photo URL capture with automatic anti-block fallback.

- 🧠 Accurate structured fields: Title, location, rating, reviews, and images—no noisy HTML scraping.
- ⚡ Fast and lightweight: Direct requests first for speed; no heavy browser automation.
- 🛡️ Resilient to blocks: Auto-switches to Apify Residential proxy and retries intelligently.
- 📦 Export-ready datasets: Download results in JSON, CSV, or Excel from Apify.
- 👨‍💻 Developer-friendly: Minimal schema, easy to consume in pipelines and Python scripts.
- 🔒 Public-only data: No login or cookies; targets publicly accessible room pages.
- 💼 Scalable batching: Paste many URLs to run a practical Airbnb photo downloader workflow.

Unlike unstable browser extensions, this production actor runs in the cloud with clear logs and dataset outputs—ideal for repeatable, large-scale tasks.

### Is it legal / ethical to use 🏠 Airbnb Images Scraper?

Yes—when done responsibly. This actor accesses publicly available Airbnb room pages without authentication and extracts structured data for analysis.

Guidelines to follow:
- Review and respect Airbnb’s Terms of Service and applicable laws in your jurisdiction.
- Use only publicly available data; avoid authenticated or private content.
- Comply with data protection regulations (e.g., GDPR, CCPA) and avoid republishing copyrighted media.
- Rate-limit and schedule responsibly; verify compliance with your legal team for edge cases.

### Input parameters & output format

Example JSON input
```json
{
  "urls": [
    "https://www.airbnb.com/rooms/782682596976136912",
    "https://www.airbnb.com/rooms/123456789012345678"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"],
    "apifyProxyCountry": "US"
  },
  "requestTimeoutSecs": 30
}
````

Input parameters

| Field | Type | Required | Default | Description |
| --- | --- | --- | --- | --- |
| urls | array of strings | Yes | — | One or more Airbnb room URLs to scrape. Each must start with https://www.airbnb.com/rooms/. |
| proxyConfiguration.useApifyProxy | boolean | No | — | Enable Apify Proxy in the UI. The actor still starts direct and enables proxy only when a block is detected. |
| proxyConfiguration.apifyProxyGroups | array of strings | No | — | Proxy groups to use when proxy is enabled (e.g., RESIDENTIAL). If unspecified, the actor uses RESIDENTIAL when it switches. |
| proxyConfiguration.apifyProxyCountry | string | No | — | Optional ISO-2 proxy country code (e.g., US, GB). Leave empty for no restriction. |
| requestTimeoutSecs | integer (5–120) | No | 30 | Maximum seconds to wait for each HTTP response before applying retry/proxy logic. |

Example JSON output (success item)

```json
{
  "url": "https://www.airbnb.com/rooms/782682596976136912",
  "title": "\"Perfect Getaway\" 2 Miles from MIA & 8To UR Cruise",
  "location": "Hialeah, Florida, United States",
  "rating": 4.95,
  "reviews": 168,
  "images": [
    "https://a0.muscache.com/im/pictures/c6cbda16-164d-481c-99d4-9d3c6344986c.jpg",
    "https://a0.muscache.com/im/pictures/hosting/Hosting-782682596976136912/original/4968ef56-67cc-481d-8b58-14f561de7735.jpeg",
    "https://a0.muscache.com/im/pictures/hosting/Hosting-782682596976136912/original/d2b52caa-5f58-4a8b-afe9-3df83eafb137.jpeg"
  ]
}
```

Example JSON output (error item)

```json
{
  "url": "https://www.airbnb.com/rooms/123456789012345678",
  "error": "Fetch failed: 403 Client Error: Forbidden"
}
```

Notes:

- Fields may return default values if missing in JSON-LD: rating defaults to 0, reviews to 0, images to \[], and location may show “Unknown, Florida, United States”.
- A run summary file (RUN\_SUMMARY.json) is saved to the key‑value store with totalUrls, success, and proxyUsed flags for quick auditing.

### FAQ

#### Is 🏠 Airbnb Images Scraper free?

No. This is a paid Apify actor. Check the Apify Store listing for the current flat monthly price and any available trial minutes.

#### Do I need to log in to Airbnb or provide cookies?

No. The actor fetches public Airbnb room pages without login and parses the embedded JSON-LD. It does not access private or authenticated content.

#### What exactly does it extract from a listing?

It returns url, title, location, rating, reviews, and images (an array of image URLs). If a page fails to fetch or parse, the record contains url and an error message instead.

#### Can I scrape multiple listings at once or bulk download Airbnb photos?

Yes. Provide multiple room URLs in the urls array. The actor will process them in one run and create an Airbnb images dataset you can use to bulk download Airbnb photos with your own downloader or pipeline.

#### How does the proxy fallback work?

The actor starts with direct requests for speed. If it detects blocks (e.g., 403, 429, captcha) or similar issues, it mints a Residential proxy URL using your proxyConfiguration (groups and optional country) and retries up to three times, then stays on proxy for subsequent requests.

#### Does it support Python or API integration?

Yes. You can run the actor via the Apify API and consume results programmatically. This fits Airbnb photo scraping Python scripts or any data pipeline using apify-client.

#### What happens if a listing has missing data?

Missing JSON-LD values are normalized: rating and reviews default to 0, images to an empty array, and location will include “Unknown” where appropriate. Failures include an error message so you can review and retry.

#### Can it crawl search results or cities?

No. This tool is a precise Airbnb photo URL extractor for room pages only. You must provide direct room URLs that start with https://www.airbnb.com/rooms/.

### Closing CTA / Final thoughts

The 🏠 Airbnb Images Scraper is built to extract listing metadata and image URLs from Airbnb room pages—fast, reliable, and automation-ready. With clean JSON output, automatic proxy fallback, and exportable datasets, it’s ideal for marketers, developers, data analysts, and researchers who need to scrape Airbnb listing photos and build a consistent Airbnb images dataset.

Run it in bulk, export to JSON/CSV/Excel, or plug it into your Python/API workflow for a streamlined Airbnb image crawler. Start extracting smarter, scalable insights from Airbnb room photos today.

# Actor input Schema

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

One or more room URLs to scrape. Each must be a valid Airbnb room page, e.g. https://www.airbnb.com/rooms/782682596976136912. Add one URL per line. At least one URL is required.

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

Proxy is not used for the first request. If the actor detects a block (403, 429, captcha, or anti-bot page), it turns on Apify Proxy using the settings here and retries. You can choose proxy groups (e.g. RESIDENTIAL) and optionally a country code. If left default, the actor uses RESIDENTIAL when it switches to proxy mode.

## `requestTimeoutSecs` (type: `integer`):

Maximum time in seconds to wait for each HTTP response. If the server doesn’t respond within this time, the request fails and retry/proxy logic applies. Default: 30. Allowed range: 5–120.

## Actor input object example

```json
{
  "urls": [
    "https://www.airbnb.com/rooms/782682596976136912"
  ],
  "requestTimeoutSecs": 30
}
```

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "urls": [
        "https://www.airbnb.com/rooms/782682596976136912"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapebase/airbnb-images-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.airbnb.com/rooms/782682596976136912"] }

# Run the Actor and wait for it to finish
run = client.actor("scrapebase/airbnb-images-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.airbnb.com/rooms/782682596976136912"
  ]
}' |
apify call scrapebase/airbnb-images-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "🏠 Airbnb Images Scraper",
        "description": "📸 Scrapes Airbnb room listing pages for structured data and image URLs. Extracts listing title, location, rating, review count, and all image URLs from one or more room URLs. Starts with direct requests for speed; if blocked or rate-limited, automatically switches to Apify Residential proxy and...",
        "version": "0.3",
        "x-build-id": "qF5iTnyqNLUSfYxkX"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapebase~airbnb-images-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapebase-airbnb-images-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/scrapebase~airbnb-images-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapebase-airbnb-images-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/scrapebase~airbnb-images-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapebase-airbnb-images-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": [
                    "urls"
                ],
                "properties": {
                    "urls": {
                        "title": "🔗 Airbnb listing URLs",
                        "type": "array",
                        "description": "One or more room URLs to scrape. Each must be a valid Airbnb room page, e.g. https://www.airbnb.com/rooms/782682596976136912. Add one URL per line. At least one URL is required.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "proxyConfiguration": {
                        "title": "🛡️ Proxy configuration (optional)",
                        "type": "object",
                        "description": "Proxy is not used for the first request. If the actor detects a block (403, 429, captcha, or anti-bot page), it turns on Apify Proxy using the settings here and retries. You can choose proxy groups (e.g. RESIDENTIAL) and optionally a country code. If left default, the actor uses RESIDENTIAL when it switches to proxy mode.",
                        "properties": {
                            "useApifyProxy": {
                                "title": "✅ Use Apify Proxy",
                                "type": "boolean",
                                "description": "Enable Apify Proxy in the UI. The actor code will still start without proxy and only enable it when a block is detected."
                            },
                            "apifyProxyGroups": {
                                "title": "📌 Proxy groups",
                                "type": "array",
                                "items": {
                                    "type": "string"
                                },
                                "description": "Apify proxy groups to use when proxy is enabled (e.g. RESIDENTIAL). Default is RESIDENTIAL when the actor switches to proxy."
                            },
                            "apifyProxyCountry": {
                                "title": "🌍 Proxy country",
                                "type": "string",
                                "description": "Optional ISO-2 country code for proxy (e.g. US, GB). Leave empty for no country restriction."
                            }
                        }
                    },
                    "requestTimeoutSecs": {
                        "title": "⏱️ Request timeout (seconds)",
                        "minimum": 5,
                        "maximum": 120,
                        "type": "integer",
                        "description": "Maximum time in seconds to wait for each HTTP response. If the server doesn’t respond within this time, the request fails and retry/proxy logic applies. Default: 30. Allowed range: 5–120.",
                        "default": 30
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
