# Images Scraper for Airbnb (`scrapeflow/airbnb-images-scraper`) Actor

- **URL**: https://apify.com/scrapeflow/airbnb-images-scraper.md
- **Developed by:** [ScrapeFlow](https://apify.com/scrapeflow) (community)
- **Categories:** Lead generation, Social media, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.99 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

### What does Airbnb Images Scraper do?

The Airbnb Images Scraper is a tool that pulls structured data directly from Airbnb listings. Instead of scrolling through endless pages, you can gather details like room type, price per night, reviews, amenities, and location data in minutes.

Compared to other Airbnb scraper tools, this one focuses on speed and simplicity. Some scrapers dig deep into every property page, which takes longer and costs more. Airbnb Images Scraper, however, captures the essentials quickly—perfect for market analysis or competitive research.

It's no surprise that people often search for Airbnb Images Scraper reviews or check Reddit discussions before using it. Those insights help users decide if it fits their workflow.

### What data can I extract with Airbnb Images Scraper?

The Airbnb Images Scraper collects the most relevant details from Airbnb listings and turns them into a usable dataset. Instead of manually copying data, you can export everything into formats like JSON, CSV, or Excel. This makes it easy to analyze pricing trends, monitor competitors, or build your own Airbnb dataset for research.

Here's a look at the kind of data you can pull:

| Field | Example |
| --- | --- |
| Listing Title | "Cozy Studio in Downtown" |
| Price per Night | $120 |
| Total Cost | $650 for 5 nights |
| Rating | 4.85 (320 reviews) |
| Room Type | Entire Home / Private Room |
| Guest Capacity | 4 Guests |
| Amenities | WiFi, Kitchen, Washer |
| Coordinates | Latitude / Longitude |
| Host Details | Superhost status, profile info |
| URL & Images | Direct links with captions |

#### Key Features of Airbnb Images Scraper

*   Fast and accurate data extraction.  
      
    
*   Works with multiple output formats (CSV, JSON, XML).  
      
    
*   Integrations with Google Sheets, Zapier, or APIs.  
      
    
*   Ideal for building your own Airbnb listing scraper dataset.  
      
    
*   Lightweight compared to deeper scrapers that crawl every detail.
    

While developers might explore Airbnb scraper GitHub projects, this tool is ready-to-use and more reliable. If you've tried the BNB Toolbox Scrape

### How to use Airbnb Images Scraper

Using the Airbnb Images Scraper is straightforward. You don't need advanced coding skills—just a few simple steps and you'll have structured Airbnb data ready to analyze.

#### Step-by-Step Guide

1.  Log in to Apify – Create a free account or sign in.  
      
    
2.  Select the Actor – Search for "Airbnb Images Scraper" in the Apify Store.  
      
    
3.  Enter Input Data – Add your target city or paste Airbnb room URLs into the locationQueries or startUrls field.  
      
    
4.  Choose Options – Set check-in/check-out dates, number of guests, price range, or room type.  
      
    
5.  Run the Actor – Hit Start, and the scraper will automatically collect Airbnb listing details.  
      
    
6.  Download Results – Export your data in JSON, CSV, XML, or HTML table formats.

#### Input
```json
{
    "urls": [
        "https://www.airbnb.com/rooms/782682596976136912"
    ]
}

````

#### Output

```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",
      "https://a0.muscache.com/im/pictures/78d3d124-225f-42a8-81d1-bcf4014dc1cc.jpg",
      "https://a0.muscache.com/im/pictures/hosting/Hosting-782682596976136912/original/13f6f3ab-9cf5-4a85-8ce0-1c0f8f8d99ef.jpeg",
      "https://a0.muscache.com/im/pictures/742148b0-c58b-4bb3-8537-6c5f9b257fd0.jpg",
      "https://a0.muscache.com/im/pictures/de5609f3-9f7f-4d46-8b39-f165fc5814ff.jpg",
      "https://a0.muscache.com/im/pictures/6c9856fb-cc9b-498b-b454-82db5b79f1df.jpg"
    ]
  }
]


```

### 🎯 Why scrape Airbnb Images Scraper?

When you're in the travel, real estate, or short-term rental space, data is leverage. Manually clicking through listings only gets you surface-level insights. The Airbnb Images Scraper flips that process: it gathers data at scale, organizes it, and makes it usable. But why does that matter? Let's break it down.

#### 1. Pricing intelligence and trend analysis

Ever wondered if your nightly rate is too high—or too low? By scraping multiple listings in your target market, you can spot average prices, seasonal fluctuations, and upcoming demand spikes. This helps hosts adjust their pricing strategy dynamically, instead of guessing.

#### 2. Competitor research for hosts

Your competitors' listings are public, but comparing them manually is a time sink. With Airbnb Images Scraper, you can track room types, guest capacities, amenities, and reviews across dozens of similar properties. That means you'll know what attracts bookings and where gaps in the market exist.

#### 3. Data for academic or market research

Researchers often need large, reliable datasets to study tourism patterns, housing availability, or urban economics. Airbnb Images Scraper creates ready-to-use datasets, perfect for analysis in tools like Excel, R, or Python. Unlike raw browsing, the output is structured and exportable.

#### 4. Comparing with other scrapers and APIs

The Booking.com scraper is useful for hotels, but it doesn't give you peer-to-peer rental data. The official Airbnb API is limited and not publicly open for most use cases. That's where Airbnb Images Scraper bridges the gap—delivering actionable, flexible data without relying on restricted endpoints.

In short, whether you're a host, analyst, or researcher, scraping Airbnb listings is less about the raw numbers and more about the decisions you can make with them.

### How many results can you scrape with Airbnb Images Scraper?

The Airbnb Images Scraper usually returns around 200–250 listings per query. That number isn't fixed—it depends on how Airbnb displays results for your chosen location, filters, and search conditions. Unlike static databases, Airbnb's platform dynamically serves listings, meaning your results can vary from one run to another.

Several factors affect the number of listings you'll actually get:

- Location size and popularity – Major cities like New York or Paris often yield more listings than smaller towns.

- Applied filters – Narrowing by price, amenities, or dates can shrink the available pool of listings.

- Airbnb's internal limits – The platform itself restricts how many results are visible at once, often capped across pages.

- Scraper performance – While the tool is optimized, concurrency settings, proxies, and timeouts can impact the total count.

To put it simply: you may see different totals depending on your input. A quick test run is always the best way to confirm how many listings are available in your target market.

For most users, 200+ listings is enough to identify pricing trends, compare amenities, and run competitor analysis. If you need broader coverage—say thousands of entries across multiple cities—you can run multiple queries or schedule recurring scrapes to build a larger Airbnb dataset over time.

This way, the scraper balances speed, cost, and reliability while still giving you enough volume to act on meaningful insights.

### How much will scraping Airbnb Images Scraper cost?

One of the best parts about the Airbnb Images Scraper is its affordable pricing model. Instead of paying high upfront fees, you pay based on the results you actually collect. The scraper operates on a fixed subscription starting at $5 per month, which makes it accessible whether you're an individual host or part of a research team.

Here's how it works: you run the Actor, it gathers listings, and you're charged per dataset generated. For example, if a scrape returns around 240 listings for a city search, your cost for that run remains covered under the monthly subscription. Compared to paying per thousand records with other tools, this predictable monthly plan keeps expenses under control.

To put it into perspective:

- Airbnb Images Scraper → $5/month flat rate.

- Some scrapers (like advanced Airbnb or Booking.com scrapers) → $0.30–$0.50 per 1,000 results.

- Custom-built solutions or premium APIs → often much higher, ranging from $20 to hundreds monthly.

For most users, $5/month is enough to cover regular scraping needs without worrying about scaling costs. If you're running larger projects or need multiple datasets daily, you can layer the tool with API access or integrate it with Google Sheets for efficient handling.

### Is it legal to scrape Airbnb Ld?

Scraping Airbnb—or any platform—always raises the question of legality. The answer isn't black and white, but here's what you should know:

#### Terms of Service

Airbnb's terms of service restrict unauthorized scraping. That means while the data is publicly visible, using automated tools to extract it may technically go against their rules. Always review Airbnb's latest policies before running large-scale scrapes.

#### Legality vs. Usage

Scraping public data itself isn't usually illegal, but how you use the data matters. If you're collecting information for research, pricing analysis, or competitor insights without redistributing Airbnb's content, risks are lower. However, republishing listings or bypassing security controls could create legal issues.

#### Ethical Best Practices

- Respect rate limits to avoid stressing Airbnb's servers.

- Anonymize and protect user data—never expose host or guest personal info.

- Use the data responsibly, for analysis and decision-making rather than duplication.

In short, Airbnb Images Scraper should be used ethically and carefully, keeping compliance in mind. Many users run small to medium scrapes for insights without issues, but the responsibility rests on how you handle the data.

### FAQ

#### Is Airbnb Images Scraper free?

No, Airbnb Images Scraper isn't free. It starts at $5 per month, which covers your scraping runs and dataset exports. Compared to custom scripts or premium APIs, it's still one of the most budget-friendly options.

#### What's the best Airbnb Images Scraper?

The "best" depends on your needs. Airbnb Images Scraper is ideal for speed, cost, and structured outputs. If you need detailed reviews or property-level deep scraping, more advanced scrapers may suit you. For most hosts, researchers, and analysts, Ld Scraper is more than enough.

#### Can I use Airbnb API instead?

Airbnb does have an official API, but access is limited and not open to everyone. Most developers and analysts can't rely on it for large-scale research. That's why scrapers like Airbnb Images Scraper fill the gap by offering broader, practical data access.

#### Is there an Airbnb scraper GitHub repo?

Yes, you'll find several open-source Airbnb scraper GitHub projects. However, they often require coding skills, setup time, and regular maintenance to stay functional. Airbnb Images Scraper skips the hassle with a ready-to-use interface.

#### Airbnb Images Scraper vs BNB Toolbox Scraper extension – which is better?

The BNB Toolbox Scraper extension works directly in your browser but is limited for small tasks. Airbnb Images Scraper, on the other hand, is cloud-based, scalable, and integrates with tools like Google Sheets or Zapier—making it the stronger choice for serious projects.

# 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("scrapeflow/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("scrapeflow/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 scrapeflow/airbnb-images-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Images Scraper for Airbnb",
        "version": "0.3",
        "x-build-id": "4xdBgop0mTaZaD7tW"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapeflow~airbnb-images-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapeflow-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/scrapeflow~airbnb-images-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapeflow-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/scrapeflow~airbnb-images-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapeflow-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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
