# Tripadvisor Reviews Scraper (`reviewly/tripadvisor-reviews-scraper`) Actor

Scrape reviews from TripAdvisor restaurant and hotel pages.

- **URL**: https://apify.com/reviewly/tripadvisor-reviews-scraper.md
- **Developed by:** [Reviewly](https://apify.com/reviewly) (community)
- **Categories:** Travel, AI, Other
- **Stats:** 2 total users, 0 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 record scrapeds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

## TripAdvisor Reviews Scraper — Extract Reviews at Scale, Pay Only for Results

**Get structured, ready-to-use TripAdvisor reviews for any restaurant, hotel, or attraction — without writing a single line of code.**

- ✅ Scrape hundreds or thousands of reviews in minutes
- ✅ Supports multiple locations in a single run
- ✅ Filter by date — only get reviews you actually need
- ✅ Pay-per-result pricing — no wasted budget
- ✅ Timeout-safe — partial data is never lost

---

### 📌 What This Actor Does

This Apify Actor scrapes customer reviews from TripAdvisor pages — restaurants, hotels, attractions, and more. You provide one or more TripAdvisor URLs, and the actor returns all reviews along with full place information in a clean, structured JSON format.

**Who is this for?**

- **Marketers & brand managers** monitoring their online reputation
- **Hospitality businesses** benchmarking against competitors
- **Data analysts & researchers** studying customer sentiment
- **Developers** building review aggregation or NLP pipelines
- **Agencies** delivering competitive intelligence to clients

---

### ✨ Key Features

- **Bulk scraping** — provide multiple TripAdvisor URLs and scrape them all in one run
- **Date filtering** — set a `targetDate` to only collect reviews newer than a given date; ideal for incremental updates
- **Review limit control** — cap the number of reviews per location with `maxNumberOfReviews`
- **Rich review data** — captures title, text, rating, sub-ratings (Food, Service, Value, Atmosphere), photos, traveler type, travel date, and owner responses
- **Full reviewer profile** — name, location, total contributions, avatar, and profile link
- **Place metadata** — overall rating, total review count, and rating histogram per star level
- **Automatic deduplication** — duplicate reviews are detected and skipped automatically
- **Timeout-safe** — if the actor is interrupted, all reviews collected so far are saved with a `partial: true` flag
- **Residential proxy support** — configure proxies directly from the Apify input panel
- **Automatic retries** — up to 10 retries with exponential backoff on network errors

---

### 🧠 Why This Actor is Different

| Feature | This Actor | Typical Alternatives |
|---|---|---|
| Pricing model | Pay-per-review | Fixed monthly or per-run |
| Output structure | Batched per location | One item per review (wasteful) |
| Timeout handling | Partial flush on abort | Data lost on timeout |
| Deduplication | Built-in | Manual post-processing |
| Date filtering | Native input field | Manual filtering needed |
| Sub-ratings | Included | Often missing |
| Owner responses | Included | Often missing |
| Reviewer photos | Included | Often missing |

Unlike browser-based scrapers that emulate a full Chrome browser (slow and expensive), this actor calls TripAdvisor's internal GraphQL API directly — making it significantly faster and more cost-efficient at scale.

---

### 💰 Pricing

This actor uses **pay-per-event** pricing — you are charged only per review successfully scraped and saved. No subscriptions, no minimum spend.

| Reviews scraped | Price per 1,000 |
|---|---|
| 1000  | **$1.00** |


No charge for reviews that fail, are deduplicated, or filtered out by date.

---

### ⚙️ Input Configuration

#### Input Fields

| Field | Type | Required | Description |
|---|---|---|---|
| `startUrls` | Array of URLs | ✅ Yes | One or more TripAdvisor page URLs to scrape |
| `maxNumberOfReviews` | Integer | No | Maximum reviews to collect per location. `0` = all reviews |
| `targetDate` | Date (YYYY-MM-DD) | No | Only collect reviews published on or after this date |
| `proxyConfiguration` | Object | No | Proxy settings — configure via the Apify proxy panel |

#### Example Input (JSON)

```json
{
  "startUrls": [
    { "url": "https://www.tripadvisor.fr/Restaurant_Review-g187265-d1322280-Reviews-Cafe_Le_Chanteclair-Lyon.html" },
    { "url": "https://www.tripadvisor.fr/Hotel_Review-g187147-d228734-Reviews-Hotel_du_Louvre-Paris.html" }
  ],
  "maxNumberOfReviews": 200,
  "targetDate": "2024-01-01",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"],
    "apifyProxyCountry": "FR"
  }
}
````

#### Tips for Best Results

- **Use residential proxies** — TripAdvisor is more likely to rate-limit datacenter IPs. Select `RESIDENTIAL` in the proxy panel.
- **Set `targetDate` for incremental runs** — if you already have reviews from a previous run, set the date to avoid re-scraping old data.
- **Set `maxNumberOfReviews` for large locations** — popular hotels can have 10,000+ reviews. Cap the limit if you only need recent ones.
- **Use `targetDate` instead of `maxNumberOfReviews` when freshness matters** — date filtering stops as soon as it hits older reviews, which is more efficient.

***

### 📤 Output Format

Each location produces **one dataset item** containing the place information and all its reviews. This keeps the data organized and avoids storing redundant place metadata on every review.

#### Sample Output

```json
{
  "placeInfo": {
    "id": 1322280,
    "name": "Café Le Chanteclair",
    "rating": 4.5,
    "numberOfReviews": 847,
    "webUrl": "https://www.tripadvisor.fr/Restaurant_Review-g187265-d1322280-Reviews-Cafe_Le_Chanteclair-Lyon.html",
    "ratingHistogram": {
      "count1": 12,
      "count2": 18,
      "count3": 54,
      "count4": 210,
      "count5": 553
    }
  },
  "reviews": [
    {
      "id": "985370123",
      "url": "https://www.tripadvisor.fr/ShowUserReviews-g187265-d1322280-r985370123.html",
      "title": "Excellent experience, highly recommended",
      "lang": "fr",
      "locationId": 1322280,
      "publishedDate": "2024-11-15T00:00:00Z",
      "publishedPlatform": "Desktop",
      "rating": 5,
      "helpfulVotes": 3,
      "text": "We had an amazing dinner here. The staff were incredibly welcoming...",
      "travelDate": "2024-11",
      "tripType": "COUPLES",
      "user": {
        "userId": "UID-00123456",
        "name": "Marie D.",
        "username": "mariedupont_lyon",
        "userLocation": "Lyon, France",
        "contributions": {
          "totalContributions": 47,
          "helpfulVotes": 12
        },
        "avatar": {
          "id": "avatar-123",
          "width": 150,
          "height": 150,
          "image": "https://media-cdn.tripadvisor.com/media/photo-t/..."
        },
        "link": "https://www.tripadvisor.fr/Profile/mariedupont_lyon"
      },
      "ownerResponse": "Thank you so much for your kind words! We look forward to welcoming you again.",
      "subratings": [
        { "name": "Food", "value": 5 },
        { "name": "Service", "value": 5 },
        { "name": "Value", "value": 4 },
        { "name": "Atmosphere", "value": 5 }
      ],
      "photos": [
        {
          "id": "photo-98765",
          "image": "https://media-cdn.tripadvisor.com/media/photo-s/..."
        }
      ]
    }
  ],
  "scrapedAt": "2025-05-21T10:34:22.000Z"
}
```

#### Output Field Reference

**`placeInfo` object**

| Field | Description |
|---|---|
| `id` | TripAdvisor internal location ID |
| `name` | Name of the restaurant, hotel, or attraction |
| `rating` | Overall average rating (1–5) |
| `numberOfReviews` | Total number of reviews on TripAdvisor |
| `webUrl` | Full URL to the TripAdvisor page |
| `ratingHistogram` | Count of reviews per star level (1–5) |

**Each `review` object**

| Field | Description |
|---|---|
| `id` | Unique review ID |
| `url` | Direct link to the review |
| `title` | Review headline |
| `lang` | Language code of the review (e.g., `"fr"`, `"en"`) |
| `publishedDate` | ISO 8601 publication date |
| `publishedPlatform` | Device used (`"Desktop"`, `"Mobile"`) |
| `rating` | Star rating given by reviewer (1–5) |
| `helpfulVotes` | Number of helpful votes from other users |
| `text` | Full review body text |
| `travelDate` | Month of visit (`"YYYY-MM"`) |
| `tripType` | Traveler type (`"COUPLES"`, `"SOLO"`, `"FAMILY"`, `"BUSINESS"`, `"FRIENDS"`) |
| `user` | Reviewer profile — name, location, contributions, avatar, link |
| `ownerResponse` | Business owner reply text (if present) |
| `subratings` | Category scores — Food, Service, Value, Atmosphere |
| `photos` | Photos attached to the review |

***

### ▶️ How to Use

#### Option 1 — No Code (Apify Console)

1. Go to the actor page in the [Apify Store](https://apify.com/store)
2. Click **Try for free**
3. In the **Input** tab, paste one or more TripAdvisor URLs into the `startUrls` field
4. (Optional) Set `maxNumberOfReviews` or `targetDate`
5. Configure proxy settings in the **Proxy** panel — recommended: Residential, country FR
6. Click **Start** and wait for the run to finish
7. Go to the **Dataset** tab to download your results as JSON, CSV, or Excel

#### Option 2 — Apify API

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/YOUR_ACTOR_ID/runs?token=YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "startUrls": [
      { "url": "https://www.tripadvisor.fr/Restaurant_Review-g187265-d1322280-Reviews-Cafe_Le_Chanteclair-Lyon.html" }
    ],
    "maxNumberOfReviews": 100,
    "targetDate": "2024-06-01"
  }'
```

#### Option 3 — Apify SDK (Node.js)

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

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

const run = await client.actor('YOUR_ACTOR_ID').call({
  startUrls: [
    { url: 'https://www.tripadvisor.fr/Restaurant_Review-g187265-d1322280-Reviews-Cafe_Le_Chanteclair-Lyon.html' }
  ],
  maxNumberOfReviews: 100,
  targetDate: '2024-06-01',
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

***

### 📈 Use Cases

#### 1. Reputation Monitoring

Scrape your restaurant's or hotel's reviews weekly and pipe them into a Slack alert or dashboard. Track rating trends and catch negative feedback before it escalates.

#### 2. Competitor Benchmarking

Pull the last 6 months of reviews for your top 10 competitors. Identify what guests love or complain about most — then use that to improve your own offering.

#### 3. Sentiment Analysis & NLP

Feed the `text` field into a sentiment analysis model or LLM to classify reviews, extract themes, or generate summaries at scale.

#### 4. Lead Generation for Hospitality Vendors

Identify restaurants or hotels with low ratings in a target city. Reach out with a targeted pitch — review management software, staff training, interior design, etc.

#### 5. Academic & Market Research

Collect large-scale datasets of traveler opinions across regions for tourism research, hospitality studies, or consumer behavior analysis.

***

### 🛠️ Advanced Tips

#### Run Multiple Locations Efficiently

Add all your target URLs to `startUrls` in a single run rather than launching separate runs per location. The actor processes them sequentially and produces one dataset item per location.

#### Incremental Scraping with `targetDate`

For weekly monitoring workflows, set `targetDate` to 7 days ago. The actor stops paginating as soon as it hits reviews older than the cutoff — saving both time and cost.

```json
{
  "targetDate": "2025-05-14"
}
```

#### Proxy Configuration for Best Reliability

For French TripAdvisor pages (`tripadvisor.fr`), use Residential proxies with `countryCode: "FR"`. This produces the most consistent results and minimizes rate-limiting.

```json
{
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"],
    "apifyProxyCountry": "FR"
  }
}
```

#### Handling Large Locations

For locations with thousands of reviews, set a reasonable `maxNumberOfReviews` (e.g., 500–1000) to keep run times and costs predictable. Pair with `targetDate` for the most efficient approach.

***

### ❓ FAQ / Troubleshooting

**Q: What types of TripAdvisor pages are supported?**
The actor supports any TripAdvisor location page with the URL pattern `...-gXXXXX-dXXXXX-...` — this covers restaurants, hotels, attractions, and experiences.

**Q: The actor returned 0 reviews. What happened?**

- Double-check that the URL contains the `-gXXXX-dXXXX-` pattern (e.g., `-g187265-d1322280-`)
- Make sure the location has public reviews on TripAdvisor
- Try switching to a Residential proxy — datacenter IPs are more likely to be blocked

**Q: I set `maxNumberOfReviews` to 200 but got fewer. Why?**
The location may have fewer than 200 total reviews, or your `targetDate` filtered out the rest. Check the run log for the `Target:` line which shows the effective cap.

**Q: Some reviews are missing their `ownerResponse` or `subratings`. Is that a bug?**
No — not all reviews have owner responses or sub-ratings. These fields are `null` when absent, which is normal TripAdvisor data.

**Q: Can I scrape TripAdvisor in English instead of French?**
The current version targets `tripadvisor.fr` and returns French reviews. Support for other locales (`.com`, `.co.uk`, etc.) is planned for a future release.

**Q: Is this legal to use?**
Web scraping publicly available data is generally permitted for personal and research use. For commercial use, consult your legal counsel and TripAdvisor's Terms of Service. This actor accesses only public data — no login, no private data.

***

### 📞 Support

Have a question, found a bug, or need a custom feature?

- 📧 Email: <me@ahmedhrid.com>
- 🐛 Issues: Use the **Issues** tab on the actor page in Apify Store
- 💬 Feature requests are welcome — response within 48 hours

***

### 💡 Conversion Improvement Suggestions

> *(Internal notes — remove before publishing)*

1. **Rename the actor** to `tripadvisor-reviews-extractor` — "extractor" signals precision and professionalism over the generic "scraper", and matches naming conventions of top-performing actors in the Apify Store.

2. **Add a 5-star review badge** to the title area once you have your first ratings — social proof dramatically increases conversion on the Apify Store.

3. **Create a short demo video** (2–3 minutes) showing a real run from input to CSV export. Actors with videos convert significantly better.

4. **Add a "Try it free" example run** — pre-fill `startUrls` with a well-known Paris restaurant and set `maxNumberOfReviews: 20` so users can see results instantly without configuration.

5. **Highlight the output format advantage** — most competing actors output one row per review (messy, repetitive). Your batched `{ placeInfo, reviews[] }` structure is cleaner for downstream processing. Make this front-and-center.

6. **Add a comparison table vs Apify's official TripAdvisor scraper** — yours is cheaper (pay-per-result vs per-run) and faster (API-based vs browser-based). Users searching for alternatives will find this compelling.

7. **Target the keyword "TripAdvisor review API"** in the description — many users are looking for an API alternative and land on Apify actors as a solution.

# Actor input Schema

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

URLs to start with.

## `maxNumberOfReviews` (type: `integer`):

The desired number of reviews to scrape (positive integer)

## `targetDate` (type: `string`):

The date to filter reviews by (optional, YYYY-MM-DD format)

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

Specifies proxy servers that will be used by the scraper in order to hide its origin.<br><br>For details, see <a href='https://apify.com/apify/web-scraper#proxy-configuration' target='_blank' rel='noopener'>Proxy configuration</a> in README.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.tripadvisor.fr/Hotel_Review-g187265-d25168957-Reviews-People_Lyon_Hotel-Lyon_Rhone_Auvergne_Rhone_Alpes.html"
    }
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# 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.tripadvisor.fr/Hotel_Review-g187265-d25168957-Reviews-People_Lyon_Hotel-Lyon_Rhone_Auvergne_Rhone_Alpes.html"
        }
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("reviewly/tripadvisor-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.tripadvisor.fr/Hotel_Review-g187265-d25168957-Reviews-People_Lyon_Hotel-Lyon_Rhone_Auvergne_Rhone_Alpes.html" }],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("reviewly/tripadvisor-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.tripadvisor.fr/Hotel_Review-g187265-d25168957-Reviews-People_Lyon_Hotel-Lyon_Rhone_Auvergne_Rhone_Alpes.html"
    }
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call reviewly/tripadvisor-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Tripadvisor Reviews Scraper",
        "description": "Scrape reviews from TripAdvisor restaurant and hotel pages.",
        "version": "0.0",
        "x-build-id": "u4LoLqoNPs501GXAA"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/reviewly~tripadvisor-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-reviewly-tripadvisor-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/reviewly~tripadvisor-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-reviewly-tripadvisor-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/reviewly~tripadvisor-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-reviewly-tripadvisor-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": "Start URLs",
                        "type": "array",
                        "description": "URLs to start with.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxNumberOfReviews": {
                        "title": "max number of reviews",
                        "minimum": 0,
                        "type": "integer",
                        "description": "The desired number of reviews to scrape (positive integer)"
                    },
                    "targetDate": {
                        "title": "date to scrape based on",
                        "type": "string",
                        "description": "The date to filter reviews by (optional, YYYY-MM-DD format)"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Specifies proxy servers that will be used by the scraper in order to hide its origin.<br><br>For details, see <a href='https://apify.com/apify/web-scraper#proxy-configuration' target='_blank' rel='noopener'>Proxy configuration</a> in README.",
                        "default": {
                            "useApifyProxy": 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
