# Trip.com Hotel Reviews Scraper (`automation-lab/trip-com-hotel-reviews-scraper`) Actor

Extract public Trip.com hotel reviews, scores, guest text, translations, traveler and room details, rating breakdowns, and media signals. Export structured data or schedule hotel reputation monitoring.

- **URL**: https://apify.com/automation-lab/trip-com-hotel-reviews-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Travel
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

## Trip.com Hotel Reviews Scraper

Extract **public Trip.com hotel reviews** into clean JSON, CSV, Excel, XML, or RSS data.
Supply one or more hotel URLs and receive newest guest comments, scores, room and traveler context, translations, media signals, and property rating breakdowns.
No Trip.com login or private API key is required.

The Actor uses a lightweight HTTP route to Trip.com's server-rendered review pages.
That makes scheduled hotel reputation monitoring fast, predictable, and inexpensive.

### What does Trip.com Hotel Reviews Scraper do?

Trip.com Hotel Reviews Scraper turns public hotel review pages into structured records ready for analysis.
Each result represents one guest review and retains its hotel context.

It extracts:

- 🏨 hotel name, address, city, country, and stable hotel ID;
- ⭐ overall score, score label, total review count, and score scale;
- 📊 location, amenities, service, and cleanliness scores;
- 🧭 traveler, room, language, and public filter counts;
- 👤 reviewer name, avatar, and contribution count;
- 🛏️ room type, stay month, and traveler type;
- 💬 score, label, date, original text, language, and translation;
- 📷 image count, media URLs, source URL, and scrape timestamp.

The public page currently provides up to 15 newest reviews per hotel.
The Actor states this limit explicitly instead of claiming unsupported deep pagination.

### Who is it for? Trip.com hotel review users

**Hotel operators and reputation managers**

- Monitor fresh feedback for one property or a portfolio.
- Route low scores and negative text into service recovery workflows.
- Track rating changes before weekly operations meetings.

**Travel agencies and hospitality consultants**

- Compare guest experience across recommended properties.
- Find recurring comments about rooms, cleanliness, location, or service.
- Build evidence-based destination and accommodation reports.

**Market intelligence and research teams**

- Collect public review text for sentiment or topic analysis.
- Compare traveler segments, room types, and rating dimensions.
- Preserve dated snapshots for competitive benchmarking.

**Developers and data teams**

- Feed structured reviews into warehouses, dashboards, LLMs, or alerts.
- Run the scraper through the Apify API, schedules, webhooks, Make, or Zapier.
- Deduplicate monitoring data with stable `reviewId` values.

### Why use this Trip.com review extractor?

- **No login required** — works with public hotel pages.
- **HTTP-first extraction** — no browser overhead for the verified route.
- **Monitoring-ready records** — stable IDs, posted dates, source URLs, and scrape timestamps.
- **Translation-aware** — keeps original and translated text separate and records translation provenance.
- **Hotel context included** — every review carries current property scores and count distributions.
- **Multi-property input** — process one hotel or a portfolio in one run.
- **Flexible exports** — use JSON, CSV, Excel, XML, RSS, or API responses.
- **Automation included** — add schedules, webhooks, alerts, and integrations on Apify.

### What Trip.com review data can you extract?

| Category | Fields |
|---|---|
| Hotel | `hotelId`, `hotelName`, `hotelAddress`, `hotelCity`, `hotelCountry` |
| Rating summary | `overallScore`, `scoreScale`, `reviewCount`, `scoreLabel` |
| Dimensions | `dimensionScores.location`, `amenities`, `service`, `cleanliness` |
| Distributions | `filterCounts`, `travelerTypeCounts`, `roomTypeCounts`, `languageCounts` |
| Reviewer | `reviewerName`, `reviewerAvatarUrl`, `reviewerContributionCount` |
| Stay | `roomType`, `stayDate`, `travelerType` |
| Review | `reviewId`, `reviewScore`, `reviewScoreScale`, `reviewLabel`, `postedAt`, `text`, `language` |
| Translation | `translatedText`, `translationLanguage`, `translationProvider`, `hasTranslation` |
| Media and provenance | `mediaCount`, `mediaUrls`, `sourceUrl`, `scrapedAt` |

Optional values are returned as `null`, not misleading placeholder strings.
Counts come from the public filter controls present at scrape time.

### How much does it cost to scrape Trip.com hotel reviews?

This Actor uses pay-per-event pricing.
A run has a small start charge and then charges for each review saved.
The formula-derived BRONZE rate is $0.000050584 per review; higher plans receive volume discounts.
Final rates are always shown in the Apify Console before a run starts.

| Example | Reviews | BRONZE item cost |
|---|---:|---:|
| One small property check | 5 | ~$0.00025 plus start |
| One full public newest-review page | 15 | ~$0.00076 plus start |
| Ten-property portfolio snapshot | 150 | ~$0.00759 plus start |

Apify's Free plan includes platform credits, so a small test is inexpensive.
Start with five reviews to inspect the data shape before scheduling a portfolio workflow.

### How to scrape Trip.com hotel reviews

1. Open Trip.com and copy a public hotel detail or `/review.html` URL.
2. Open this Actor in the Apify Store.
3. Add the URL under **🏨 Trip.com hotel URLs**.
4. Choose 1–15 newest reviews per hotel.
5. Click **Start**.
6. Preview the dataset or export it as JSON, CSV, Excel, XML, or RSS.
7. Add a schedule if you want recurring reputation monitoring.

The Actor automatically converts a normal hotel detail URL to its review page.
Duplicate URLs and duplicate review IDs are emitted only once.

### Input parameters

| Parameter | Type | Required | Default | Description |
|---|---|---:|---:|---|
| `startUrls` | array | Yes | Sample hotel | Public Trip.com hotel detail or review URLs |
| `maxReviewsPerHotel` | integer | No | 10 | Newest reviews per hotel, from 1 through 15 |

Only public `trip.com` hotel-detail URLs are accepted.
This prevents accidental requests to unrelated pages or private resources.

### Input examples

**Small first run**

```json
{
  "startUrls": [
    { "url": "https://www.trip.com/hotels/singapore-hotel-detail-687499/hotel-81-tristar/review.html" }
  ],
  "maxReviewsPerHotel": 5
}
````

**Normal hotel detail URL**

```json
{
  "startUrls": [
    { "url": "https://www.trip.com/hotels/singapore-hotel-detail-687499/hotel-81-tristar/" }
  ],
  "maxReviewsPerHotel": 15
}
```

**Portfolio monitoring**

```json
{
  "startUrls": [
    { "url": "https://www.trip.com/hotels/singapore-hotel-detail-687499/hotel-81-tristar/review.html" },
    { "url": "https://www.trip.com/hotels/singapore-hotel-detail-996216/hotel-boss/review.html" }
  ],
  "maxReviewsPerHotel": 15
}
```

### Output example

```json
{
  "reviewId": "1969916536",
  "hotelId": "687499",
  "hotelName": "Hotel 81 Tristar",
  "hotelAddress": "1 Onan Rd, Singapore, 424780, Singapore",
  "hotelCity": "Singapore",
  "hotelCountry": "Singapore",
  "overallScore": 8.2,
  "scoreScale": 10,
  "reviewCount": 446,
  "scoreLabel": "Very good",
  "dimensionScores": {
    "location": 8.7,
    "amenities": 7.7,
    "service": 8.4,
    "cleanliness": 7.9
  },
  "reviewerName": "Guest User",
  "reviewerContributionCount": 2,
  "roomType": "Deluxe Queen Room",
  "stayDate": "2026-06",
  "travelerType": "Traveling with friends",
  "reviewScore": 10,
  "reviewScoreScale": 10,
  "reviewLabel": "Outstanding",
  "postedAt": "2026-06-02T11:44:34.000Z",
  "text": "Hello, is a nice place to stay for relaxing...",
  "language": "en",
  "hasTranslation": false,
  "mediaCount": 3,
  "sourceUrl": "https://www.trip.com/hotels/singapore-hotel-detail-687499/hotel-81-tristar/review.html",
  "scrapedAt": "2026-07-14T00:00:00.000Z"
}
```

The live record also includes distribution arrays, avatar and media URLs, and translation fields.

### Tips for best results

- Begin with one hotel and five reviews.
- Use canonical hotel-detail or review URLs copied from Trip.com.
- Schedule runs daily or weekly depending on review velocity.
- Deduplicate downstream on `reviewId` when appending snapshots.
- Compare `overallScore` and `reviewCount` between snapshots to detect changes.
- Use `text` for original-language analysis and `translatedText` for English workflows.
- Keep the source URL with every warehouse record for auditability.

### Hotel reputation monitoring workflow

Run the Actor on a schedule and append each dataset to a long-term store.
Use `reviewId` to identify newly observed feedback.
Then calculate changes in:

- newest low-scoring reviews;
- overall property score;
- total public review count;
- cleanliness, location, amenities, and service scores;
- traveler and room-type composition.

A webhook can trigger a Slack alert whenever a new review falls below your chosen score.

### Integrations

**Trip.com reviews → Google Sheets**

Append newest feedback to an operations sheet and filter by property, score, or traveler type.

**Trip.com reviews → Slack or Discord**

Send an alert for new low scores, negative labels, or important translated comments.

**Trip.com reviews → Make or Zapier**

Create tickets, update a CRM property record, or notify a hotel manager automatically.

**Trip.com reviews → data warehouse**

Load stable review records into BigQuery, Snowflake, PostgreSQL, or another analytics system.

**Scheduled runs and webhooks**

Use Apify schedules for monitoring and webhooks to start downstream processing immediately after completion.

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/trip-com-hotel-reviews-scraper').call({
  startUrls: [{ url: 'https://www.trip.com/hotels/singapore-hotel-detail-687499/hotel-81-tristar/review.html' }],
  maxReviewsPerHotel: 10,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Using the Apify API with Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/trip-com-hotel-reviews-scraper').call(run_input={
    'startUrls': [{'url': 'https://www.trip.com/hotels/singapore-hotel-detail-687499/hotel-81-tristar/review.html'}],
    'maxReviewsPerHotel': 10,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### Using the Apify API with cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~trip-com-hotel-reviews-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"startUrls":[{"url":"https://www.trip.com/hotels/singapore-hotel-detail-687499/hotel-81-tristar/review.html"}],"maxReviewsPerHotel":10}'
```

Use the returned dataset ID to download results after the run finishes.

### Use with AI agents via MCP

This Actor is available to AI assistants through the [Model Context Protocol](https://docs.apify.com/platform/integrations/mcp).

For Claude Code:

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/trip-com-hotel-reviews-scraper"
```

For Claude Desktop, Cursor, or VS Code:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/trip-com-hotel-reviews-scraper"
    }
  }
}
```

Example prompts — try asking:

- “Use `automation-lab/trip-com-hotel-reviews-scraper` to collect the newest reviews for these Trip.com hotel URLs.”
- “Compare cleanliness and service scores for my Singapore hotel portfolio.”
- “Find new reviews below 7/10 and summarize translated guest complaints by property.”

Your client will ask you to authenticate with Apify on first use.

### Legality: Is it legal to scrape Trip.com reviews?

Scraping public web data is generally permitted when done responsibly, but laws and website terms vary.
Use the Actor only for legitimate purposes, collect the minimum data needed, respect applicable privacy and database rules, and avoid attempts to access private information.
You are responsible for your input, usage, retention, and compliance with Trip.com's terms and applicable laws such as GDPR.
This Actor accesses only anonymously available hotel review pages and does not bypass login controls.

### Limitations

- The Actor extracts up to 15 newest reviews exposed in the public SSR page per hotel.
- It does not claim complete historical pagination.
- Trip.com can change page structure or temporarily challenge automated requests.
- Some reviews omit room type, traveler type, avatar, translation, or media.
- Ratings and count distributions reflect Trip.com's public values at scrape time.
- The Actor does not perform sentiment scoring; use the extracted text with your preferred model.

### Troubleshooting

**Why did my URL fail validation?**

Use a public `https://www.trip.com/hotels/...-hotel-detail-.../` URL.
Search pages, account pages, shortened links, and other domains are intentionally rejected.

**Why are there fewer than 15 results?**

The hotel may expose fewer public reviews, duplicate review IDs may have been removed, or you selected a lower limit.
Check the log and the public page.

**Why is translated text null?**

Trip.com only supplies a translation for some non-English reviews.
The original `text` and `language` remain available.

**What if Trip.com returns a temporary error?**

Retry later with the same small input.
The Actor performs bounded retries and reports the failing hotel URL clearly.

### FAQ

**How fast is the scraper?**

HTTP extraction usually processes a hotel page in seconds without launching a browser.
Network conditions and Trip.com response time can vary.

**Does it require a Trip.com API key or account?**

No. The supported v1 reads publicly rendered hotel review pages.

**Can it scrape all historical reviews?**

Not in this version.
It intentionally returns the newest public SSR rows, up to 15 per hotel, which is useful for repeat monitoring.

**How can I detect only new reviews?**

Store prior `reviewId` values and compare them with the next scheduled dataset.
Stable IDs make this straightforward.

**Can I export to Excel?**

Yes. Open the default dataset, click Export, and choose Excel, CSV, JSON, XML, or RSS.

**Can I monitor multiple hotels?**

Yes. Add multiple Trip.com hotel URLs to `startUrls` and schedule the Actor.

**How are translations represented?**

Original and translated text are separate fields, with language and provider metadata where available.

### Related travel and hotel scrapers

Extend your travel intelligence workflow with Automation Labs actors:

- [Booking Scraper](https://apify.com/automation-lab/booking-scraper) — hotel listings and property data.
- [Booking Reviews Scraper](https://apify.com/automation-lab/booking-reviews-scraper) — guest review monitoring across another major OTA.
- [Google Maps Scraper](https://apify.com/automation-lab/google-maps-scraper) — local business ratings, reviews, and place data.
- [Airbnb Scraper](https://apify.com/automation-lab/airbnb-scraper) — accommodation listings and market research.
- [Tripadvisor Scraper](https://apify.com/automation-lab/tripadvisor-scraper) — travel review and attraction intelligence.

Choose only the actors needed for your workflow and verify their current availability on the Apify Store.

### Data quality and responsible monitoring

Review text is user-generated and can contain opinions, errors, or sensitive context.
Do not treat a single review as verified fact.
Aggregate trends, retain source links, document collection times, and provide human review for consequential decisions.

For recurring analytics, keep both `postedAt` and `scrapedAt`.
The first describes when Trip.com says the review was posted; the second records when your pipeline observed it.

# Actor input Schema

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

Public Trip.com hotel detail or /review.html URLs. The Actor automatically opens the review version and removes duplicates.

## `maxReviewsPerHotel` (type: `integer`):

Number of newest SSR reviews to save from each hotel page. Trip.com currently exposes up to 15 on the public page.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.trip.com/hotels/singapore-hotel-detail-687499/hotel-81-tristar/review.html"
    }
  ],
  "maxReviewsPerHotel": 10
}
```

# Actor output Schema

## `overview` (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 = {
    "startUrls": [
        {
            "url": "https://www.trip.com/hotels/singapore-hotel-detail-687499/hotel-81-tristar/review.html"
        }
    ],
    "maxReviewsPerHotel": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/trip-com-hotel-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 = {
    "startUrls": [{ "url": "https://www.trip.com/hotels/singapore-hotel-detail-687499/hotel-81-tristar/review.html" }],
    "maxReviewsPerHotel": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/trip-com-hotel-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 '{
  "startUrls": [
    {
      "url": "https://www.trip.com/hotels/singapore-hotel-detail-687499/hotel-81-tristar/review.html"
    }
  ],
  "maxReviewsPerHotel": 10
}' |
apify call automation-lab/trip-com-hotel-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Trip.com Hotel Reviews Scraper",
        "description": "Extract public Trip.com hotel reviews, scores, guest text, translations, traveler and room details, rating breakdowns, and media signals. Export structured data or schedule hotel reputation monitoring.",
        "version": "0.1",
        "x-build-id": "t2ExDaz1ty796nBbX"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~trip-com-hotel-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-trip-com-hotel-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/automation-lab~trip-com-hotel-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-trip-com-hotel-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/automation-lab~trip-com-hotel-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-trip-com-hotel-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": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "🏨 Trip.com hotel URLs",
                        "type": "array",
                        "description": "Public Trip.com hotel detail or /review.html URLs. The Actor automatically opens the review version and removes duplicates.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxReviewsPerHotel": {
                        "title": "Maximum newest reviews per hotel",
                        "minimum": 1,
                        "maximum": 15,
                        "type": "integer",
                        "description": "Number of newest SSR reviews to save from each hotel page. Trip.com currently exposes up to 15 on the public page.",
                        "default": 10
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```