# Expedia Reviews Scraper, Fast Lightweight (`mof1re/expedia-reviews-scraper`) Actor

Scrape hotel reviews from Expedia by URL or hotel ID. Extract ratings, review text, traveler type, guest experience score, owner replies, and more. Filter by keyword or traveler type. Fast and reliable — no Expedia API needed.

- **URL**: https://apify.com/mof1re/expedia-reviews-scraper.md
- **Developed by:** [Vladimir Efimenco](https://apify.com/mof1re) (community)
- **Categories:** Developer tools, Travel, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## Expedia Reviews Scraper | Fast, Lightweight

This Expedia Reviews Scraper pulls hotel reviews directly from Expedia's internal GraphQL API, no browser involved. Returns full review text, ratings, traveler type, guest experience score, and owner replies for any hotel listed on Expedia.

### ⚡ Why this Expedia Reviews Scraper

- **No browser session required.** Most Expedia review scrapers launch a headless browser just to render the page before they can read anything. This one talks to the same GraphQL API that Expedia's own app uses, so there's nothing to render and nothing to wait on.
- **Full review content, not a snapshot.** Each review comes with the title, full text, numeric rating, rating label, traveler type, publish date, and whether the stay was verified.
- **Hotel-level stats included.** Guest rating, total number of ratings, and guest experience score are attached to every review from that listing.
- **Sort and filter built in.** Sort by most recent, most relevant, or rating (high to low or low to high), filter by traveler type, and search by keyword, either through Expedia's own filter or checked locally against the review text.
- **Batch scraping.** Feed in multiple hotel URLs or IDs and they run concurrently in the same job.
- **Proxies included.** No need to bring your own, residential and datacenter proxies are already wired in.
- **Fast.** Pure HTTP requests to Expedia's API, no page load, no rendering delay.

### 🎯 Who uses this Expedia Reviews Scraper

- **Hospitality market researchers** tracking guest sentiment, rating trends, or traveler type breakdowns (business, couples, families, solo) across hotels or regions.
- **Competitor benchmarking teams** comparing guest ratings and experience scores across properties in the same market.
- **Reputation management agencies** monitoring new reviews and owner replies for a portfolio of hotel clients.
- **Sentiment analysis and NLP teams** feeding review text into models, pre-filtered by keyword or rating.
- **Developers building travel or hospitality dashboards** who need structured Expedia review data without maintaining their own scraper.

### 🧾 What you get, per review

- Review content: title, text, rating (numeric and label), review date, locale
- Traveler info: reviewer name, traveler type, verified stay flag
- Owner reply: reply title and text, if the property responded
- What guests liked and disliked, where Expedia surfaces it separately
- Hotel-wide stats: guest rating, total ratings count, guest experience score
- Keyword match: whether the search query matched this review

### 🔍 How keyword search works

The `search` field works the same way as Expedia's own review search box.

- **`searchIsLocalFilter` unchecked (default):** the keyword is sent to Expedia as a server-side filter. Only matching reviews come back, and each one is marked `is_keyword_match: true`.
- **`searchIsLocalFilter` checked:** the keyword is not sent to Expedia. Every review is fetched regardless, and each one is checked locally against the title and text, with `is_keyword_match` showing the result.

Use the checked option when you want the complete review set but still need to flag which reviews mention your keyword.

### 🔧 Input options

| Field | Description |
|---|---|
| `listingUrls` | One or more Expedia hotel URLs, or plain numeric hotel IDs |
| `maxResults` | Max reviews to collect per listing. Leave empty to collect all available |
| `sortBy` | Sort order: most recent, most relevant, rating high to low, rating low to high |
| `travelerType` | Filter by traveler type: business, couples, families, families with young children, groups, solo, travelers with pets |
| `search` | Keyword to search for in reviews |
| `searchIsLocalFilter` | If checked, `search` tags reviews locally instead of filtering them via Expedia |

### 📊 Data Fields

#### 📝 Review Details

| Field | Description |
|---|---|
| `review_id` | Unique ID of the review |
| `rating_number` / `rating_value` / `rating_text` | Reviewer's overall rating, as a number, value, and text label |
| `review_title` / `review_text` | Review title and body text |
| `review_date` | Date the review was published |
| `review_locale` | Language the review was written in |
| `what_liked` / `what_disliked` | What the guest liked and disliked, if Expedia surfaces it |
| `review_images` | Image URLs with caption text, if any |
#### 👤 Reviewer

| Field | Description |
|---|---|
| `reviewer_name` | Name of the reviewer |
| `review_is_verified` | Whether the stay is marked verified |
| `travel_type` | Business, couples, family, friends, solo, etc. |

#### 🏢 Owner & Listing

| Field | Description |
|---|---|
| `review_reply_title` / `review_reply_text` | Property owner's reply, if any |
| `listing_name` / `listing_type` | Name and type of the hotel |
| `reviews_overall_stats` | Guest rating, total ratings, guest experience score |

#### ⭐ Matching

| Field | Description |
|---|---|
| `query_keyword` | The search keyword provided in actor input, if any |
| `is_keyword_match` | True if the query matched this review, either checked locally or because Expedia's own filter already applied it |

### 📋 Example output

```json
[
  {
    "listing_name": "ibis Praha Mala Strana",
    "listing_type": "Hotel",
    "reviews_overall_stats": {
      "guest_rating": 8.6,
      "total_ratings": 789,
      "guest_experience_score": 8.4
    },
    "review_id": "67ec19ad15d5c874a2ad47b5",
    "rating_number": 10,
    "rating_value": "10/10",
    "rating_text": "Excellent",
    "review_locale": null,
    "review_title": "",
    "review_text": "Good option for cheap accommodation if you are looking to avoid shared rooms. Ibis is always one of my go to's when i am specifically looking for a basic but comfortable and cheap private room.",
    "what_liked": "Liked: cleanliness, staff & service, property conditions & facilities",
    "what_disliked": null,
    "review_date": "Apr 1, 2025",
    "review_reply_title": null,
    "review_reply_text": null,
    "review_images": [],
    "reviewer_name": "Roy",
    "review_is_verified": true,
    "travel_type": "Traveled with partner",
    "query_keyword": null,
    "is_keyword_match": false
  },
  {
    "listing_name": "ibis Praha Mala Strana",
    "listing_type": "Hotel",
    "reviews_overall_stats": {
      "guest_rating": 8.6,
      "total_ratings": 789,
      "guest_experience_score": 8.4
    },
    "review_id": "68a7af5a4b7654488031b2a2",
    "rating_number": 8,
    "rating_value": "8/10",
    "rating_text": "Good",
    "review_locale": "de_DE",
    "review_title": "",
    "review_text": "It’s in the centrum all shops available supermarket etc.",
    "what_liked": "Liked: cleanliness, staff & service",
    "what_disliked": null,
    "review_date": "Aug 21, 2025",
    "review_reply_title": "Response from ibis team on Aug 27, 2025",
    "review_reply_text": "Dear Guest,\n\nThank you for your feedback. We appreciate your insights and strive to enhance our guests' experiences.\n\nWarm regards,\nibis Praha Mala Strana",
    "review_images": [],
    "reviewer_name": "Rosemary",
    "review_is_verified": true,
    "travel_type": "Traveled with family and young children",
    "query_keyword": null,
    "is_keyword_match": false
  },
  {
    "listing_name": "ibis Praha Mala Strana",
    "listing_type": "Hotel",
    "reviews_overall_stats": {
      "guest_rating": 8.6,
      "total_ratings": 789,
      "guest_experience_score": 8.4
    },
    "review_id": "68ae39df794d9610b2c357f0",
    "rating_number": 10,
    "rating_value": "10/10",
    "rating_text": "Excellent",
    "review_locale": null,
    "review_title": "",
    "review_text": "Just off a busy major street. Trams, buses, and shopping center (including an Albert supermarket) just a block away, as well as fast food options.\nThe room was clean, modern, and perfect for a short stay. Shower was excellent, bed was extra firm. A/C and a window that opens. Would definitely stay there again.",
    "what_liked": "Liked: cleanliness, staff & service, property conditions & facilities",
    "what_disliked": null,
    "review_date": "Aug 26, 2025",
    "review_reply_title": "Response from ibis team on Aug 27, 2025",
    "review_reply_text": "Dear Guest,\n\nThank you for your feedback. We appreciate your insights and strive to enhance our guests' experiences.\n\nWarm regards,\nibis Praha Mala Strana",
    "review_images": [
      {
        "url": "https://a.travel-assets.com/ugc/hotel-reviews/54ffeeeb-15db-4f8e-a99a-45b3e4e5fa36-1756249104053.jpg",
        "image_text": "Unless you need a fridge or microwave, this room fill the needs."
      }
    ],
    "reviewer_name": "Daniel",
    "review_is_verified": true,
    "travel_type": "Solo traveler",
    "query_keyword": null,
    "is_keyword_match": false
  }
]
````

### 🚀 Running the actor

#### Via Apify Console

Open the actor page, fill in the input form, and click **Start**.

#### Via Apify API: Python

```python
import requests

APIFY_TOKEN = "your_apify_token"
ACTOR_ID = "mof1re~expedia-reviews-scraper"

run_input = {
    "listingUrls": [
        {"url": "https://www.expedia.com/Prague-Hotels-Hotel-Krystal.h10966026.Hotel-Information"}
    ],
    "maxResults": 200,
    "sortBy": "most_recent",
    "travelerType": "",
    "search": "",
    "searchIsLocalFilter": False
}

response = requests.post(
    f"https://api.apify.com/v2/acts/{ACTOR_ID}/run-sync-get-dataset-items",
    params={"token": APIFY_TOKEN},
    json=run_input,
)

reviews = response.json()
print(f"Fetched {len(reviews)} reviews")
```

#### Via Apify API: Node.js

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

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

const input = {
    listingUrls: [
        { url: 'https://www.expedia.com/Prague-Hotels-Hotel-Krystal.h10966026.Hotel-Information' }
    ],
    maxResults: 200,
    sortBy: 'most_recent',
    travelerType: '',
    search: '',
    searchIsLocalFilter: false,
};

const run = await client.actor('mof1re/expedia-reviews-scraper').call(input);
const { items } = await client.dataset(run.defaultDatasetId).listItems();

console.log(`Fetched ${items.length} reviews`);
```

#### Example input JSON

```json
{
  "listingUrls": [
    { "url": "https://www.expedia.com/Prague-Hotels-Hotel-Krystal.h10966026.Hotel-Information" },
    { "url": "190551" }
  ],
  "maxResults": 200,
  "sortBy": "rating_high",
  "travelerType": "couples",
  "search": "clean",
  "searchIsLocalFilter": false
}
```

### ❓ FAQ

**How is this different from other Expedia review scrapers?** Most run a full browser to load the page before pulling reviews. This one calls Expedia's GraphQL API directly and supports sorting, traveler type filtering, and dual-mode keyword search together, in one input.

**Does this scraper need an account or API key?** No. It extracts publicly available review data.

**Can I pass a hotel ID instead of a URL?** Yes. Drop the numeric Expedia hotel ID straight into `listingUrls` and it works the same as a full URL.

**Can I filter reviews by traveler type?** Yes. Set `travelerType` to business, couples, families, families with young children, groups, solo, or travelers with pets.

**Do I need my own proxies?** No. Proxies are built into the actor.

**Is this legal? Can I scrape publicly available reviews?** This tool extracts publicly available review data. You're responsible for complying with the target site's terms of service and applicable data protection laws for your use case.

### 💳 Pricing

Pay-per-result. You're charged for reviews actually delivered, not for pages fetched or requests made.

### ⚠️ Notes

- Free-tier accounts are capped at a small sample size per run, and to a single listing per run. Upgrade to a paid Apify plan for full volume and batch scraping.
- Data reflects what's publicly listed on expedia.com at the time of the run; the source updates continuously.

### 🔗 See also

Need reviews from another platform? Check out:

- [Tripadvisor Reviews Scraper](https://apify.com/mof1re/tripadvisor-reviews-scraper)
- [Booking.com Reviews Scraper](https://apify.com/mof1re/booking-reviews-scraper-browserless)
- [AirBnb Reviews Scraper](https://apify.com/mof1re/airbnb-reviews-scraper-browserless)
- [Trustpilot Reviews Scraper](https://apify.com/mof1re/trustpilot-scraper-fast-browserlessapif)
- [ULTA Reviews Scraper](https://apify.com/mof1re/ulta-reviews-scraper)

# Actor input Schema

## `listingUrls` (type: `array`):

Expedia listing URLs or numeric hotel IDs to scrape reviews from.

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

Maximum number of reviews to scrape per listing. Leave empty to try to get all reviews.

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

Order in which reviews are returned.

## `travelerType` (type: `string`):

Filter reviews by traveler type. Leave empty to include all types.

## `search` (type: `string`):

Filter reviews containing this keyword.

## `searchIsLocalFilter` (type: `boolean`):

If enabled, keyword filtering is applied locally to already-fetched reviews. If disabled, the keyword is sent to Expedia and results returned are treated as already matched.

## Actor input object example

```json
{
  "listingUrls": [
    "https://www.expedia.com/Prague-Hotels-Hotel-Krystal.h10966026.Hotel-Information",
    "190551"
  ],
  "maxResults": 100,
  "searchIsLocalFilter": false
}
```

# Actor output Schema

## `jobAds` (type: `string`):

No description

# 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 = {
    "listingUrls": [
        "https://www.expedia.com/Prague-Hotels-Hotel-Krystal.h10966026.Hotel-Information",
        "190551"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("mof1re/expedia-reviews-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 = { "listingUrls": [
        "https://www.expedia.com/Prague-Hotels-Hotel-Krystal.h10966026.Hotel-Information",
        "190551",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("mof1re/expedia-reviews-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 '{
  "listingUrls": [
    "https://www.expedia.com/Prague-Hotels-Hotel-Krystal.h10966026.Hotel-Information",
    "190551"
  ]
}' |
apify call mof1re/expedia-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Expedia Reviews Scraper, Fast Lightweight",
        "description": "Scrape hotel reviews from Expedia by URL or hotel ID. Extract ratings, review text, traveler type, guest experience score, owner replies, and more. Filter by keyword or traveler type. Fast and reliable — no Expedia API needed.",
        "version": "0.1",
        "x-build-id": "xlAiz1LrK4PoJcSs8"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/mof1re~expedia-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-mof1re-expedia-reviews-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/mof1re~expedia-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-mof1re-expedia-reviews-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/mof1re~expedia-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-mof1re-expedia-reviews-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": [
                    "listingUrls"
                ],
                "properties": {
                    "listingUrls": {
                        "title": "🔗 Listing URLs or IDs",
                        "type": "array",
                        "description": "Expedia listing URLs or numeric hotel IDs to scrape reviews from.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "🔢 Max reviews per listing",
                        "type": "integer",
                        "description": "Maximum number of reviews to scrape per listing. Leave empty to try to get all reviews.",
                        "default": 100
                    },
                    "sortBy": {
                        "title": "↕️ Sort by",
                        "enum": [
                            "",
                            "most_recent",
                            "relevant",
                            "rating_high",
                            "rating_low"
                        ],
                        "type": "string",
                        "description": "Order in which reviews are returned."
                    },
                    "travelerType": {
                        "title": "🧳 Traveler type",
                        "enum": [
                            "",
                            "business_travelers",
                            "couples",
                            "families",
                            "families_with_young_children",
                            "groups",
                            "solo_travelers",
                            "travelers_with_pets"
                        ],
                        "type": "string",
                        "description": "Filter reviews by traveler type. Leave empty to include all types."
                    },
                    "search": {
                        "title": "🔍 Search keyword",
                        "type": "string",
                        "description": "Filter reviews containing this keyword."
                    },
                    "searchIsLocalFilter": {
                        "title": "🔄 Search is local filter",
                        "type": "boolean",
                        "description": "If enabled, keyword filtering is applied locally to already-fetched reviews. If disabled, the keyword is sent to Expedia and results returned are treated as already matched.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
