# Hotel & Stay Price Comparison (`trovevault/hotel-stay-price-comparison`) Actor

Compares bookable hotels and stays with totalStayPrice, pricePerNight, amenities, rating, reviewCount, and bookingUrl.

- **URL**: https://apify.com/trovevault/hotel-stay-price-comparison.md
- **Developed by:** [Trove Vault](https://apify.com/trovevault) (community)
- **Categories:** Travel, Real estate, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.25 / 1,000 rooms

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

## Hotel & Stay Price Comparison

Hotel & Stay Price Comparison helps travel planners, revenue teams, event organizers, and relocation researchers compare public hotel and stay options for a destination and date range. Give it a city or destination, check-in and check-out dates, guest count, room count, budget filters, and amenity requirements. It returns one dataset row per stay option with buyer-facing fields such as `propertyName`, `accommodationType`, `totalStayPrice`, `pricePerNight`, `currency`, `bookingUrl`, `rating`, `reviewCount`, `amenities`, and `missingRequestedAmenities`.

Use it when you need a structured short list of bookable accommodation options instead of manually checking travel pages and copying prices into spreadsheets. The actor is designed for comparison, monitoring, and workflow automation, not for final checkout confirmation.

### Why use this actor

- Compare hotel-style and short-term-rental-style options in one Apify dataset.
- Prioritize stays by total trip cost, nightly price, rating, review count, and amenity fit.
- Keep booking links in the output so each option can be inspected before purchase.
- Flag missing requested amenities instead of forcing manual page review.
- Append results to an existing dataset with `datasetId` for recurring travel or relocation tracking.
- Pass `runId` through the output when this actor is part of a larger TroveVault pipeline.

### What it extracts

Each stay row can include:

| Field | Meaning |
| --- | --- |
| `propertyName` | Accommodation name visible on the public booking page. |
| `accommodationType` | Normalized type such as hotel, aparthotel, guesthouse, or short-term-rental-style stay. |
| `totalStayPrice` | Total stay price when the actor can detect a trustworthy value. |
| `pricePerNight` | Nightly price derived from total price and stay length when trustworthy. |
| `currency` | Requested or detected currency. |
| `bookingUrl` | Public booking URL for manual inspection or booking. |
| `rating` / `reviewCount` | Public rating and review count when visible. |
| `amenities` | Normalized amenities detected from public page text. |
| `missingRequestedAmenities` | Required amenities that were not detected. |
| `cancellationSignal` / `breakfastSignal` | Visible policy or meal signals when available. |
| `roomFit` | Basic signal for guest and room fit. |

The actor also writes run-level diagnostics to `RUN_SUMMARY`, including coverage and limitations for the run.

### Use cases

- **Business travel sourcing:** shortlist hotels under a maximum total stay budget and export rows to a travel approval sheet.
- **Conference and event planning:** compare options around a city for a fixed date range and identify stays missing required amenities.
- **Relocation research:** monitor available apartments, aparthotels, guesthouses, and hotel options in a target city.
- **Travel deal tracking:** schedule recurring runs for the same destination and compare `totalStayPrice`, `rating`, and `reviewCount` over time.
- **Marketplace enrichment:** feed normalized accommodation rows into internal dashboards, BI tools, or recommendation workflows.

### How to use it

1. Enter the destination, for example `Lisbon, Portugal`.
2. Set `checkIn`, `checkOut`, `guests`, and `rooms`.
3. Optionally choose accommodation types, currency, maximum total price, and amenities.
4. Start the actor and review the `Stay Options` dataset view.
5. Open `bookingUrl` for any stay that looks promising before booking.

### Input example

```json
{
  "destination": "Lisbon, Portugal",
  "checkIn": "2026-09-12",
  "checkOut": "2026-09-15",
  "guests": 2,
  "rooms": 1,
  "accommodationTypes": ["hotel", "aparthotel", "guesthouse", "short_term_rental"],
  "maxTotalPrice": 1000,
  "currency": "EUR",
  "requiredAmenities": ["wifi"],
  "preferredAmenities": ["breakfast", "workspace"],
  "maxResults": 25,
  "runId": "lisbon-september-shortlist"
}
````

#### Input reference

| Field | Required | Description |
| --- | --- | --- |
| `destination` | Yes | City, area, or destination to search. Include the country when possible. |
| `checkIn` / `checkOut` | Yes | Stay dates in YYYY-MM-DD format. |
| `guests` | Yes | Number of guests. |
| `rooms` | Yes | Number of rooms. |
| `accommodationTypes` | No | Types to include, such as hotel, aparthotel, guesthouse, or short-term-rental-style stays. |
| `maxTotalPrice` | No | Optional budget cap for the whole stay. |
| `currency` | No | Preferred currency such as EUR, USD, or GBP. |
| `requiredAmenities` | No | Amenities that should be checked and reported in `missingRequestedAmenities`. |
| `preferredAmenities` | No | Amenities used for comparison and review. |
| `maxResults` | No | Maximum number of stay rows to return. |
| `datasetId` | No | Existing dataset to append rows into. |
| `runId` | No | Your own workflow identifier copied into run metadata. |

### Output example

```json
{
  "propertyName": "Alameda Prime Suites",
  "accommodationType": "hotel",
  "totalStayPrice": 287,
  "pricePerNight": 95.67,
  "currency": "EUR",
  "bookingUrl": "https://www.booking.com/hotel/pt/alameda-prime-suites.html",
  "rating": 9.3,
  "reviewCount": 11,
  "amenities": ["wifi", "air_conditioning", "pool", "breakfast", "workspace", "family_friendly"],
  "missingRequestedAmenities": [],
  "cancellationSignal": "cancellation_policy_visible",
  "breakfastSignal": "breakfast_available",
  "roomFit": "standard_room_search",
  "destination": "Lisbon, Portugal",
  "checkIn": "2026-09-12",
  "checkOut": "2026-09-15",
  "guests": 2,
  "rooms": 1,
  "scrapedAt": "2026-06-22T17:45:48.710Z"
}
```

### API usage

```bash
curl -X POST "https://api.apify.com/v2/acts/trovevault~hotel-stay-price-comparison/runs" \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "destination": "Lisbon, Portugal",
    "checkIn": "2026-09-12",
    "checkOut": "2026-09-15",
    "guests": 2,
    "rooms": 1,
    "accommodationTypes": ["hotel", "aparthotel", "guesthouse", "short_term_rental"],
    "currency": "EUR",
    "maxResults": 25
  }'
```

### Limitations

- Prices are public-page signals, not final checkout quotes. Taxes, fees, discounts, and availability can change before booking.
- Some public accommodation pages challenge automated sessions, change markup, localize content, or hide fees until later checkout steps.
- `totalStayPrice` and `pricePerNight` are returned as `null` when the actor cannot detect a trustworthy price.
- Amenities are normalized from visible text and should be verified on the booking page before purchase.
- Short-term rentals are included only when public booking pages expose apartment, studio, villa, home, or similar stay listings in the same accommodation search flow.
- The actor does not log in, bypass access controls, or guarantee full market coverage.

### Troubleshooting

| Problem | What to try |
| --- | --- |
| No rows returned | Use a broader destination, increase `maxResults`, remove strict budget or amenity filters, and confirm the date range is valid. |
| Prices are `null` | Public pages may have hidden or ambiguous pricing. Open `bookingUrl` and inspect the current checkout page. |
| Too many options miss an amenity | Check that the amenity name is common and visible in public listing text. Try a simpler term such as `wifi` or `breakfast`. |
| Results are outside the expected area | Include country or region in `destination`, for example `Porto, Portugal` rather than `Porto`. |
| Run is slow or blocked | Lower `maxResults`, retry later, or enable Apify Proxy if public pages are challenging datacenter traffic. |

### FAQ

**Does this actor book rooms automatically?**\
No. It returns public stay options and booking links for human review.

**Can I use it for short-term rentals?**\
Yes, when those stays appear as public accommodation types in the same search flow. It is not a separate Airbnb integration.

**Which price should I use?**\
Use `totalStayPrice` for trip budgeting because it reflects the full stay when trustworthy. Use `pricePerNight` for cross-stay comparison.

**Why are some fields null?**\
A field is null when the public page did not expose a value clearly enough to parse without guessing.

**Can I schedule this actor?**\
Yes. Schedule repeated runs and use `datasetId` if you want to append comparable rows into a long-lived dataset.

**Is this suitable for final purchasing decisions?**\
Use it for shortlist and monitoring workflows. Always verify current price, fees, cancellation terms, and availability on the booking page.

**Does it expose source diagnostics in the dataset?**\
No. Operational diagnostics stay in logs and `RUN_SUMMARY` so the buyer-facing table remains clean.

### Related actors

- Remote Work Hub Market Analyzer for comparing cities as remote-work destinations.
- Sustainable Travel Certification Tracker for accommodation sustainability signals.
- Conference Events Scout for event and travel planning workflows.

### Changelog

- 0.1: Booking-based hotel and stay comparison with total price, nightly price, amenity matching, rating, review count, booking URL, `datasetId`, and `runId` support.

### Feedback and support

Open an issue on the actor page with the input JSON, run ID, expected destination, and a short description of the missing or incorrect result.

# Actor input Schema

## `destination` (type: `string`):

City, neighborhood, region, or destination to search. Use a specific place for cleaner results, such as Lisbon, Portugal or Baixa, Lisbon.

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

Arrival date in YYYY-MM-DD format. Prices and room availability are date-dependent.

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

Departure date in YYYY-MM-DD format. Must be after check-in.

## `guests` (type: `integer`):

Number of guests staying. This affects pricing, room fit, and short-term rental availability.

## `rooms` (type: `integer`):

Number of rooms needed for hotel-style stays. Use 1 for most leisure or solo business searches.

## `accommodationTypes` (type: `array`):

Types of stays to compare. Short-term rental covers apartment, studio, villa, home, and similar stay listings exposed in the accommodation search.

## `maxTotalPrice` (type: `integer`):

Preferred maximum price for the whole stay, not just nightly rate. The default is intentionally broad so the built-in smoke run stays resilient.

## `currency` (type: `string`):

Preferred display currency for source searches where supported.

## `requiredAmenities` (type: `array`):

Amenities that should be present. Leave empty for broad searches or smoke tests.

## `preferredAmenities` (type: `array`):

Nice-to-have amenities. Matching preferred amenities improve value and fit, but missing them is not treated as a hard warning.

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

Maximum ranked accommodation rows to save. The default is one row so the built-in Apify test stays fast; increase it for real comparison runs.

## `datasetId` (type: `string`):

Optional existing Apify dataset ID to append the same ranked rows to, in addition to the default run dataset.

## `runId` (type: `string`):

Optional identifier copied to output rows for downstream tracing in larger workflows.

## Actor input object example

```json
{
  "destination": "Lisbon, Portugal",
  "checkIn": "2026-09-12",
  "checkOut": "2026-09-15",
  "guests": 2,
  "rooms": 1,
  "accommodationTypes": [
    "hotel",
    "aparthotel",
    "guesthouse",
    "short_term_rental"
  ],
  "maxTotalPrice": 1000,
  "currency": "EUR",
  "requiredAmenities": [],
  "preferredAmenities": [],
  "maxResults": 1
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

## `summary` (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 = {
    "destination": "Lisbon, Portugal",
    "checkIn": "2026-09-12",
    "checkOut": "2026-09-15",
    "guests": 2,
    "rooms": 1,
    "accommodationTypes": [
        "hotel",
        "aparthotel",
        "guesthouse",
        "short_term_rental"
    ],
    "maxTotalPrice": 1000,
    "requiredAmenities": [],
    "preferredAmenities": [],
    "maxResults": 1
};

// Run the Actor and wait for it to finish
const run = await client.actor("trovevault/hotel-stay-price-comparison").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 = {
    "destination": "Lisbon, Portugal",
    "checkIn": "2026-09-12",
    "checkOut": "2026-09-15",
    "guests": 2,
    "rooms": 1,
    "accommodationTypes": [
        "hotel",
        "aparthotel",
        "guesthouse",
        "short_term_rental",
    ],
    "maxTotalPrice": 1000,
    "requiredAmenities": [],
    "preferredAmenities": [],
    "maxResults": 1,
}

# Run the Actor and wait for it to finish
run = client.actor("trovevault/hotel-stay-price-comparison").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 '{
  "destination": "Lisbon, Portugal",
  "checkIn": "2026-09-12",
  "checkOut": "2026-09-15",
  "guests": 2,
  "rooms": 1,
  "accommodationTypes": [
    "hotel",
    "aparthotel",
    "guesthouse",
    "short_term_rental"
  ],
  "maxTotalPrice": 1000,
  "requiredAmenities": [],
  "preferredAmenities": [],
  "maxResults": 1
}' |
apify call trovevault/hotel-stay-price-comparison --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=trovevault/hotel-stay-price-comparison",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Hotel & Stay Price Comparison",
        "description": "Compares bookable hotels and stays with totalStayPrice, pricePerNight, amenities, rating, reviewCount, and bookingUrl.",
        "version": "0.1",
        "x-build-id": "fQfZtJP2Qng3yib5O"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/trovevault~hotel-stay-price-comparison/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-trovevault-hotel-stay-price-comparison",
                "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/trovevault~hotel-stay-price-comparison/runs": {
            "post": {
                "operationId": "runs-sync-trovevault-hotel-stay-price-comparison",
                "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/trovevault~hotel-stay-price-comparison/run-sync": {
            "post": {
                "operationId": "run-sync-trovevault-hotel-stay-price-comparison",
                "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": [
                    "destination",
                    "checkIn",
                    "checkOut",
                    "guests",
                    "rooms",
                    "accommodationTypes"
                ],
                "properties": {
                    "destination": {
                        "title": "Destination",
                        "type": "string",
                        "description": "City, neighborhood, region, or destination to search. Use a specific place for cleaner results, such as Lisbon, Portugal or Baixa, Lisbon.",
                        "default": "Lisbon, Portugal"
                    },
                    "checkIn": {
                        "title": "Check-in date",
                        "type": "string",
                        "description": "Arrival date in YYYY-MM-DD format. Prices and room availability are date-dependent.",
                        "default": "2026-09-12"
                    },
                    "checkOut": {
                        "title": "Check-out date",
                        "type": "string",
                        "description": "Departure date in YYYY-MM-DD format. Must be after check-in.",
                        "default": "2026-09-15"
                    },
                    "guests": {
                        "title": "Guests",
                        "minimum": 1,
                        "maximum": 16,
                        "type": "integer",
                        "description": "Number of guests staying. This affects pricing, room fit, and short-term rental availability.",
                        "default": 2
                    },
                    "rooms": {
                        "title": "Rooms",
                        "minimum": 1,
                        "maximum": 8,
                        "type": "integer",
                        "description": "Number of rooms needed for hotel-style stays. Use 1 for most leisure or solo business searches.",
                        "default": 1
                    },
                    "accommodationTypes": {
                        "title": "Accommodation types",
                        "minItems": 1,
                        "type": "array",
                        "description": "Types of stays to compare. Short-term rental covers apartment, studio, villa, home, and similar stay listings exposed in the accommodation search.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "hotel",
                                "aparthotel",
                                "motel",
                                "hostel",
                                "guesthouse",
                                "resort",
                                "short_term_rental"
                            ],
                            "enumTitles": [
                                "Hotel",
                                "Aparthotel",
                                "Motel",
                                "Hostel",
                                "Guesthouse",
                                "Resort",
                                "Short-term rental"
                            ]
                        },
                        "default": [
                            "hotel",
                            "aparthotel",
                            "guesthouse",
                            "short_term_rental"
                        ]
                    },
                    "maxTotalPrice": {
                        "title": "Max total stay price",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Preferred maximum price for the whole stay, not just nightly rate. The default is intentionally broad so the built-in smoke run stays resilient.",
                        "default": 1000
                    },
                    "currency": {
                        "title": "Currency",
                        "enum": [
                            "EUR",
                            "USD",
                            "GBP"
                        ],
                        "type": "string",
                        "description": "Preferred display currency for source searches where supported.",
                        "default": "EUR"
                    },
                    "requiredAmenities": {
                        "title": "Required amenities",
                        "type": "array",
                        "description": "Amenities that should be present. Leave empty for broad searches or smoke tests.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "wifi",
                                "air_conditioning",
                                "kitchen",
                                "washer",
                                "dryer",
                                "free_parking",
                                "pool",
                                "gym",
                                "breakfast",
                                "workspace",
                                "pet_friendly",
                                "family_friendly",
                                "accessible",
                                "self_check_in"
                            ],
                            "enumTitles": [
                                "Wifi",
                                "Air conditioning",
                                "Kitchen",
                                "Washer",
                                "Dryer",
                                "Free parking",
                                "Pool",
                                "Gym",
                                "Breakfast",
                                "Workspace",
                                "Pet friendly",
                                "Family friendly",
                                "Accessible",
                                "Self check-in"
                            ]
                        },
                        "default": []
                    },
                    "preferredAmenities": {
                        "title": "Preferred amenities",
                        "type": "array",
                        "description": "Nice-to-have amenities. Matching preferred amenities improve value and fit, but missing them is not treated as a hard warning.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "wifi",
                                "air_conditioning",
                                "kitchen",
                                "washer",
                                "dryer",
                                "free_parking",
                                "pool",
                                "gym",
                                "breakfast",
                                "workspace",
                                "pet_friendly",
                                "family_friendly",
                                "accessible",
                                "self_check_in"
                            ],
                            "enumTitles": [
                                "Wifi",
                                "Air conditioning",
                                "Kitchen",
                                "Washer",
                                "Dryer",
                                "Free parking",
                                "Pool",
                                "Gym",
                                "Breakfast",
                                "Workspace",
                                "Pet friendly",
                                "Family friendly",
                                "Accessible",
                                "Self check-in"
                            ]
                        },
                        "default": []
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum ranked accommodation rows to save. The default is one row so the built-in Apify test stays fast; increase it for real comparison runs.",
                        "default": 1
                    },
                    "datasetId": {
                        "title": "Dataset ID",
                        "type": "string",
                        "description": "Optional existing Apify dataset ID to append the same ranked rows to, in addition to the default run dataset."
                    },
                    "runId": {
                        "title": "Run ID",
                        "type": "string",
                        "description": "Optional identifier copied to output rows for downstream tracing in larger workflows."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
