# Airbnb Scraper (`khadinakbar/airbnb-scraper`) Actor

Extract Airbnb listings, prices, ratings, host data, amenities & GPS coordinates for any location. Search by city or scrape direct listing URLs. Returns CRM-ready structured JSON. Export scraped data, run via API, schedule and monitor runs, or integrate with other tools.

- **URL**: https://apify.com/khadinakbar/airbnb-scraper.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** Travel, Lead generation, Automation
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 listing scrapeds

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

## 🏠 Airbnb Scraper — Extract Listings, Prices & Host Data

### What does Airbnb Scraper do?

Airbnb Scraper extracts structured data from Airbnb listings for any location worldwide — prices, ratings, host info, amenities, GPS coordinates, and more. Search by city, region, or zip code, or pass in direct listing URLs for targeted extraction.

### Why use Airbnb Scraper?

- **No manual browsing** — scrape hundreds of listings in minutes, not hours
- **Structured JSON output** — clean, analysis-ready data for spreadsheets, databases, or AI pipelines
- **Dual input mode** — search by destination OR scrape specific listing URLs
- **Rich host data** — Superhost status, response rate, response time per listing
- **MCP-compatible** — works seamlessly with Claude, ChatGPT, and other AI agents via the Apify MCP server

### What data can Airbnb Scraper extract?

| Field | Description | Example |
|---|---|---|
| `listing_id` | Airbnb's unique listing ID | `12345678` |
| `listing_url` | Direct URL to the listing | `https://airbnb.com/rooms/12345678` |
| `name` | Listing title | `Cozy Downtown Loft with City Views` |
| `description` | Full listing description | `Welcome to our beautiful...` |
| `property_type` | Home, room, hotel room, etc. | `Entire home` |
| `room_type` | Airbnb room type category | `entire_home` |
| `price_per_night` | Nightly price (numeric) | `120` |
| `price_currency` | Currency code | `USD` |
| `original_price_per_night` | Pre-discount price | `150` |
| `cleaning_fee` | One-time cleaning charge | `45` |
| `total_price` | Full stay total (when dates given) | `385` |
| `rating` | Average guest rating (1–5) | `4.87` |
| `review_count` | Number of reviews | `234` |
| `host_name` | Host display name | `Sarah` |
| `host_id` | Airbnb host ID | `9876543` |
| `is_superhost` | Superhost status | `true` |
| `host_response_rate` | % of messages responded to | `100%` |
| `host_response_time` | Typical response speed | `within an hour` |
| `city` | City | `New York` |
| `state` | State or region | `NY` |
| `country` | Country | `United States` |
| `neighborhood` | Neighborhood / district | `Lower East Side` |
| `latitude` | GPS latitude | `40.7128` |
| `longitude` | GPS longitude | `-74.0060` |
| `bedrooms` | Number of bedrooms | `2` |
| `beds` | Number of beds | `3` |
| `bathrooms` | Number of bathrooms | `1.5` |
| `max_guests` | Max guest capacity | `4` |
| `amenities` | List of amenities | `["WiFi", "Kitchen", "Pool"]` |
| `thumbnail_url` | Main listing photo URL | `https://a0.muscache.com/...` |
| `photos` | All photo URLs (array) | `[...]` |
| `minimum_nights` | Minimum stay required | `2` |
| `cancellation_policy` | Cancellation policy name | `Flexible` |
| `check_in_time` | Check-in time | `3:00 PM` |
| `check_out_time` | Check-out time | `11:00 AM` |
| `is_available` | Available for your dates | `true` |
| `scraped_at` | ISO timestamp of scrape | `2026-04-09T12:00:00.000Z` |
| `source_url` | URL this record was scraped from | `https://airbnb.com/s/...` |

---

### Tutorial: How to Use Airbnb Scraper

#### Method 1 — Search by Location (most common)

1. Open the actor and fill in **Location / Search Query** (e.g. `Miami Beach, FL`)
2. Optionally set check-in/check-out dates to get accurate pricing and availability
3. Set **Maximum Results** (1–300 recommended per search)
4. Click **Start** — results arrive in the Output tab within minutes

#### Method 2 — Scrape Specific Listings

1. Copy the Airbnb listing URL(s) you want to scrape (e.g. `https://www.airbnb.com/rooms/12345678`)
2. Paste them into **Direct Listing URLs**
3. Leave **Location / Search Query** empty
4. Click **Start** — each listing is scraped for full detail data

#### Using Filters

Narrow your results with optional filters:

- **Check-in / Check-out dates** — filters to available properties, gives accurate pricing
- **Adults / Children / Pets** — filters by guest capacity and pet-friendliness
- **Min / Max Price** — set a nightly rate budget range
- **Minimum Bedrooms** — filter by bedroom count
- **Property Type** — Entire home, Private room, or Hotel room only

---

### Input Parameters

| Parameter | Type | Default | Description |
|---|---|---|---|
| `locationQuery` | string | — | City, region, or address to search (e.g. "Paris, France") |
| `startUrls` | array | — | Direct Airbnb listing URLs to scrape |
| `checkIn` | string | — | Check-in date (YYYY-MM-DD) |
| `checkOut` | string | — | Check-out date (YYYY-MM-DD) |
| `adults` | integer | 2 | Number of adult guests |
| `children` | integer | 0 | Number of child guests |
| `pets` | integer | 0 | Number of pets |
| `minPrice` | integer | — | Minimum nightly price (USD) |
| `maxPrice` | integer | — | Maximum nightly price (USD) |
| `minBedrooms` | integer | — | Minimum bedroom count |
| `propertyType` | string | all | `entire_home`, `private_room`, `hotel_room`, or empty for all |
| `maxResults` | integer | 50 | Maximum number of listings to scrape |
| `proxyConfiguration` | object | Residential | Proxy settings (residential recommended) |

---

### Pricing

This actor uses **pay-per-event pricing** — you only pay for listings actually scraped. No subscription, no monthly fees.

| Volume | Cost |
|---|---|
| 100 listings | $0.20 |
| 500 listings | $1.00 |
| 1,000 listings | $2.00 |
| 10,000 listings | $20.00 |

All costs include compute, proxy, and storage — no surprises.

---

### Code Examples

#### JavaScript / Node.js

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

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });

const run = await client.actor('khadinakbar/airbnb-scraper').call({
    locationQuery: 'Miami Beach, FL',
    checkIn: '2026-06-01',
    checkOut: '2026-06-07',
    adults: 2,
    maxResults: 100,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Scraped ${items.length} listings`);
console.log(items[0]);
````

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_API_TOKEN')

run = client.actor('khadinakbar/airbnb-scraper').call(run_input={
    'locationQuery': 'Miami Beach, FL',
    'checkIn': '2026-06-01',
    'checkOut': '2026-06-07',
    'adults': 2,
    'maxResults': 100,
})

items = list(client.dataset(run['defaultDatasetId']).iterate_items())
print(f'Scraped {len(items)} listings')
print(items[0])
```

#### Via API (cURL)

```bash
curl -X POST "https://api.apify.com/v2/acts/khadinakbar~airbnb-scraper/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "locationQuery": "Miami Beach, FL",
    "maxResults": 50
  }'
```

***

### Use Cases

**Real estate investment research** — Compare nightly rates across neighborhoods to identify high-performing vacation rental markets. Export to Excel and calculate projected annual revenue.

**Competitive pricing analysis** — Property managers can benchmark their listing against comps in the same area, same bedroom count, same guest capacity.

**Travel market research** — Researchers and analysts can track pricing trends, seasonal availability, and Superhost density across destinations.

**AI-powered travel assistants** — With the Apify MCP server, Claude and other AI agents can call this scraper directly in response to queries like "find me pet-friendly 2-bedroom listings in Austin under $200/night."

**Hospitality industry data** — Track inventory levels, average ratings, and amenity trends across specific markets for hotel and property management companies.

***

### Works Great With

- **[Apify Shopify Scraper](https://apify.com/khadinakbar/shopify-all-in-one-scraper)** — For e-commerce data alongside your rental research
- **Apify Dataset → Google Sheets integration** — Export results directly to spreadsheets
- **Apify Scheduler** — Run weekly to track price trends over time

***

### FAQ

**How many results can I get per search?**
Airbnb typically surfaces up to 300 results per search query. To get more, run multiple searches with different filters (price ranges, neighborhoods, etc.).

**Does this require Airbnb login?**
No — this actor scrapes publicly available listing data. No Airbnb account or credentials required.

**How accurate are the prices?**
Prices are most accurate when you provide check-in/check-out dates. Without dates, you'll see the base nightly rate but not cleaning fees or total stay costs.

**Why did I get fewer results than expected?**
Airbnb may return fewer listings than requested if there aren't enough listings matching your filters. Try broadening your search (remove price filters, reduce guest count, expand the location).

**Can I scrape reviews?**
The current version extracts the rating score and review count. Detailed individual reviews are not included in this version.

**What proxy do I need?**
The actor uses Apify's residential proxy pool by default, which works well for Airbnb. Datacenter proxies may be blocked — residential is recommended.

***

### Legal Disclaimer

This actor is intended for lawful data collection from publicly available information on Airbnb. Users are responsible for compliance with applicable laws, Airbnb's Terms of Service, and data protection regulations (GDPR, CCPA, etc.). The author does not condone unauthorized data collection or any use that violates platform terms. Always use scraped data responsibly.

Export scraped data, run the scraper via API, schedule and monitor runs, or integrate with other tools.

# Actor input Schema

## `locationQuery` (type: `string`):

Use this when the user provides a city, neighborhood, region, or destination name (e.g. 'New York', 'Paris', 'Miami Beach, FL'). The actor will search Airbnb for listings at this location. Do NOT use this when you have specific listing URLs — use startUrls instead.

## `startUrls` (type: `array`):

Use this when the user provides specific Airbnb listing URLs (e.g. 'https://www.airbnb.com/rooms/12345678'). Do NOT use this when the user describes a location or destination — use locationQuery for that.

## `checkIn` (type: `string`):

Check-in date in YYYY-MM-DD format (e.g. '2026-06-15'). Used in search mode to filter available listings and get accurate pricing. Leave empty to see all listings regardless of dates.

## `checkOut` (type: `string`):

Check-out date in YYYY-MM-DD format (e.g. '2026-06-20'). Must be after checkIn if provided.

## `adults` (type: `integer`):

Number of adult guests. Filters listings by guest capacity.

## `children` (type: `integer`):

Number of child guests (ages 2–12).

## `pets` (type: `integer`):

Number of pets. Filters results to pet-friendly listings only.

## `minPrice` (type: `integer`):

Minimum nightly price in USD. Filters out listings below this price.

## `maxPrice` (type: `integer`):

Maximum nightly price in USD. Filters out listings above this price.

## `minBedrooms` (type: `integer`):

Minimum number of bedrooms required.

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

Filter by property type. 'entire\_home' = private home/apartment. 'private\_room' = shared accommodations. 'hotel\_room' = hotels/boutique hotels. Leave empty for all types.

## `maxResults` (type: `integer`):

Maximum number of listings to scrape. Recommended: 50–300. Airbnb typically returns up to 300 results per search.

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

Proxy settings for scraping. Residential proxies recommended for Airbnb. Leave default to use Apify's proxy pool.

## Actor input object example

```json
{
  "locationQuery": "New York, NY",
  "adults": 2,
  "children": 0,
  "pets": 0,
  "propertyType": "",
  "maxResults": 50,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `results` (type: `string`):

Scraped Airbnb listing data stored in the default dataset.

# 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 = {
    "locationQuery": "New York, NY",
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/airbnb-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 = {
    "locationQuery": "New York, NY",
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/airbnb-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 '{
  "locationQuery": "New York, NY",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call khadinakbar/airbnb-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Airbnb Scraper",
        "description": "Extract Airbnb listings, prices, ratings, host data, amenities & GPS coordinates for any location. Search by city or scrape direct listing URLs. Returns CRM-ready structured JSON. Export scraped data, run via API, schedule and monitor runs, or integrate with other tools.",
        "version": "1.0",
        "x-build-id": "tJOpguYwbRj9S73zX"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/khadinakbar~airbnb-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-khadinakbar-airbnb-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/khadinakbar~airbnb-scraper/runs": {
            "post": {
                "operationId": "runs-sync-khadinakbar-airbnb-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/khadinakbar~airbnb-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-khadinakbar-airbnb-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "locationQuery": {
                        "title": "Location / Search Query",
                        "type": "string",
                        "description": "Use this when the user provides a city, neighborhood, region, or destination name (e.g. 'New York', 'Paris', 'Miami Beach, FL'). The actor will search Airbnb for listings at this location. Do NOT use this when you have specific listing URLs — use startUrls instead."
                    },
                    "startUrls": {
                        "title": "Direct Listing URLs",
                        "type": "array",
                        "description": "Use this when the user provides specific Airbnb listing URLs (e.g. 'https://www.airbnb.com/rooms/12345678'). Do NOT use this when the user describes a location or destination — use locationQuery for that.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "checkIn": {
                        "title": "Check-in Date",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Check-in date in YYYY-MM-DD format (e.g. '2026-06-15'). Used in search mode to filter available listings and get accurate pricing. Leave empty to see all listings regardless of dates."
                    },
                    "checkOut": {
                        "title": "Check-out Date",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Check-out date in YYYY-MM-DD format (e.g. '2026-06-20'). Must be after checkIn if provided."
                    },
                    "adults": {
                        "title": "Number of Adults",
                        "minimum": 1,
                        "maximum": 16,
                        "type": "integer",
                        "description": "Number of adult guests. Filters listings by guest capacity.",
                        "default": 2
                    },
                    "children": {
                        "title": "Number of Children",
                        "minimum": 0,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Number of child guests (ages 2–12).",
                        "default": 0
                    },
                    "pets": {
                        "title": "Number of Pets",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Number of pets. Filters results to pet-friendly listings only.",
                        "default": 0
                    },
                    "minPrice": {
                        "title": "Minimum Price per Night (USD)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum nightly price in USD. Filters out listings below this price."
                    },
                    "maxPrice": {
                        "title": "Maximum Price per Night (USD)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum nightly price in USD. Filters out listings above this price."
                    },
                    "minBedrooms": {
                        "title": "Minimum Bedrooms",
                        "minimum": 0,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Minimum number of bedrooms required."
                    },
                    "propertyType": {
                        "title": "Property Type",
                        "enum": [
                            "",
                            "entire_home",
                            "private_room",
                            "hotel_room"
                        ],
                        "type": "string",
                        "description": "Filter by property type. 'entire_home' = private home/apartment. 'private_room' = shared accommodations. 'hotel_room' = hotels/boutique hotels. Leave empty for all types.",
                        "default": ""
                    },
                    "maxResults": {
                        "title": "Maximum Results",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of listings to scrape. Recommended: 50–300. Airbnb typically returns up to 300 results per search.",
                        "default": 50
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings for scraping. Residential proxies recommended for Airbnb. Leave default to use Apify's proxy pool."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
