# CHECK24 Hotel Reviews Scraper (`valiant_quarter/check24-hotel-reviews-scraper`) Actor

Scrape hotel reviews from CHECK24: customer ratings (1-10), verified feedback text, travel dates, traveler type info, and detailed guest insights — all as structured JSON.

- **URL**: https://apify.com/valiant\_quarter/check24-hotel-reviews-scraper.md
- **Developed by:** [valiant quarter](https://apify.com/valiant_quarter) (community)
- **Categories:** Travel, Developer tools, Integrations
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$19.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## CHECK24 Hotel Reviews Scraper

Scrape verified hotel guest reviews from **CHECK24 Hotelvergleich** with ratings, detailed feedback, travel dates, and guest information in JSON format.

### What You Get

- **Complete review texts** including positive, neutral, and negative feedback
- **Guest ratings** on a 1–10 scale per review, plus aggregate category ratings
- **Verified stays** — all reviews are from confirmed bookers on CHECK24
- **Travel metadata** — dates, traveler type (family, couple, solo, etc.), room types
- **Guest profiles** — names (often anonymized), visit counts, locations
- **Site-specific fields** — season, business trip flag, pet-friendly stay indicator
- **Structured JSON** ready for analytics, comparison tools, and review aggregation

### Key Features

✓ **Fast and cheap** — HTTP API only (no browser); 390 reviews in ~5 seconds  
✓ **High volume** — Process thousands of hotels via the [Apify Scheduler](https://docs.apify.com/platform/actors/tasks)  
✓ **Date filtering** — Extract reviews from specific date ranges (e.g., "summer 2026")  
✓ **Limit controls** — Scrape first N reviews to save costs  
✓ **Scalable** — Batch process multiple hotels per run  
✓ **Production-ready** — Retry logic, proxy support, error handling  

### What It Does NOT Include

- **No owner replies** — CHECK24 does not publish hotelier responses (unlike HolidayCheck or Expedia)
- **No review photos** — Gallery media not exposed in the API
- **No per-review category scores** — Only hotel-wide aggregate ratings available

This is by design; CHECK24 offers **first-party, verified guest reviews** that stand alone without management responses.

### Use Cases

#### Review Aggregation & Analysis
Combine CHECK24 reviews with data from HolidayCheck, Expedia, and Zoover for comprehensive multi-source review analytics and sentiment analysis.

#### Price Intelligence
Cross-reference reviews with booking data to identify review volume trends and guest satisfaction patterns before/after price changes.

#### Competitor Monitoring
Track review trends across competitor hotels in a region or segment (e.g., 5-star all-inclusives in Turkey).

#### Review Moderation
Export all reviews in structured format for moderation, compliance, or content management systems.

#### Research & Reports
Generate data exports for academic research, travel guides, or industry benchmarks.

### How It Works

1. **Extract hotel ID** — Actor parses the CHECK24 hotel URL to find the clusterId.
2. **Fetch reviews** — Queries the public JSON API (`/api-hotel/proxy/portale/cluster/{id}/reviews/list.json`).
3. **Paginate** — Loops through pages (100 reviews per page) until all are fetched or limit is hit.
4. **Filter dates** — Optionally filters reviews by publication date (client-side).
5. **Normalize** — Maps CHECK24 field names to standard schema.
6. **Output** — Pushes each review as JSON to the dataset.

### Input Parameters

#### Hotel URLs (`startUrls`) — required

CHECK24 hotel URLs in this format:
````

https://hotel.check24.de/search/{HotelName}-{clusterId}/hotel.html

````

Query parameters (e.g., `?c9=...`) are optional and ignored.

#### Max Reviews per Hotel

Default: `0` (all reviews). Set to a number (e.g., `50`) to limit cost.

#### Date Range

- **Review date from** (YYYY-MM-DD) — Scrape only reviews published on/after this date.
- **Review date to** (YYYY-MM-DD) — Scrape only reviews published on/before this date.

Both are optional; leave blank for no date limit.

#### Raw Data

If enabled, includes the raw API response payload in each review (`raw` field) for advanced debugging.

### Output Format

#### Per-Review Fields

```json
{
  "hotelId": "8914316",
  "hotelName": "Lago Hotel",
  "reviewId": "019e9207-e994-7282-8794-093cd531ce80",
  "title": "Wonderful stay",
  "text": "The hotel is beautiful...",
  "generalRating": 8,
  "ratingScale": 10,
  "travelDate": "2026-05-30T00:00:00.000Z",
  "entryDate": "2026-06-04T00:00:00.000Z",
  "traveledWith": "FAMILY",
  "user": { "name": "Anonym" },
  "season": "spring",
  "ownerResponse": null
}
````

#### Summary Statistics

A SUMMARY record shows per-hotel totals: reviews scraped, total on site, owner response count (always 0 for CHECK24).

### Pricing & Performance

| Setup | Reviews | Duration | Cost\* |
|-------|---------|----------|-------|
| All reviews (Lago) | 390 | 5 s | $0.006 |
| First 100 | 100 | 1 s | $0.002 |
| Date range | ~50 | 5 s | $0.008 |

*Estimates based on Apify's $0.015 per 1,000 results (actual varies by plan).*

### FAQ

**Q: Why no owner responses?**\
A: CHECK24 does not publish hotelier replies. The platform focuses on verified guest reviews. For owner responses, use the HolidayCheck or Zoover actors.

**Q: Can I scrape multiple hotels at once?**\
A: Yes, add multiple URLs to `startUrls`. Each hotel is crawled sequentially.

**Q: How do I filter reviews by date?**\
A: Use the `dateFrom` and `dateTo` input fields (YYYY-MM-DD format). Filtering happens client-side after fetching.

**Q: Is it legal to scrape CHECK24?**\
A: CHECK24's reviews are public and scraped via their public API. Always respect their terms of service and robots.txt. For commercial use, contact CHECK24's business team.

**Q: What languages are supported?**\
A: Reviews are primarily German (CHECK24's main market). The `originalLocale` field indicates the language of each review.

**Q: Do I need a proxy?**\
A: No. The actor works with datacenter IPs. Residential proxies are optional fallback for future rate-limiting.

### Limitations & Notes

- **No photos** — Review images are not available via the API.
- **Aggregate ratings only** — Category ratings (room, service, cleanliness) are hotel-level, not per-review.
- **Relevance sort** — Server only supports sorting by relevance; date-based sorting is client-side.
- **German platform** — Some fields (seasons, traveler types) are localized to German.

### Support & Documentation

- **GitHub:** [check24-review-scraper](https://github.com/your-org/check24-review-scraper) (open-source)
- **Full README:** Installation, examples, troubleshooting
- **NOTES.md:** Technical deep-dive, API endpoints, field mappings
- **Apify Docs:** [Actor Development](https://docs.apify.com/platform/actors)

### Related Actors

- **[HolidayCheck Reviews Scraper](https://apify.com/...)** — German reviews with owner responses
- **[Expedia Reviews Scraper](https://apify.com/...)** — Global reviews with hotel replies
- **[Zoover Reviews Scraper](https://apify.com/...)** — European reviews with management comments

***

**Version:** 1.0\
**Node.js:** ≥ 18\
**Apify SDK:** 3.2.6+\
**Last Updated:** 2026-07-16

***

**Keywords:** CHECK24, hotel reviews, web scraper, review scraping, hotel ratings, guest feedback, German hotels, data extraction, JSON API, Apify actor

# Actor input Schema

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

CHECK24 hotel URLs. Extract the clusterId from the URL path (e.g., 8914316 from /search/Hotel-Name-8914316/hotel.html)

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

Maximum number of reviews to scrape per hotel (ordered by relevance). Use 0 to scrape all reviews.

## `dateFrom` (type: `string`):

Only include reviews published on or after this date (YYYY-MM-DD). Leave empty for no lower limit.

## `dateTo` (type: `string`):

Only include reviews published on or before this date (YYYY-MM-DD). Leave empty for no upper limit.

## `includeRawData` (type: `boolean`):

Attach the raw API payload for each review under the `raw` key.

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

Proxy settings. CHECK24 API works with datacenter IPs; Apify automatic proxy is recommended.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://hotel.check24.de/search/Lago%20Hotel-8914316/hotel.html"
    }
  ],
  "maxReviewsPerHotel": 0,
  "includeRawData": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `reviews` (type: `string`):

All scraped reviews with ratings, feedback text, and guest metadata (JSON)

## `summary` (type: `string`):

Per-hotel counts: reviews scraped, total ratings on site, run duration

# 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://hotel.check24.de/search/Lago%20Hotel-8914316/hotel.html"
        }
    ],
    "maxReviewsPerHotel": 0,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("valiant_quarter/check24-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://hotel.check24.de/search/Lago%20Hotel-8914316/hotel.html" }],
    "maxReviewsPerHotel": 0,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("valiant_quarter/check24-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://hotel.check24.de/search/Lago%20Hotel-8914316/hotel.html"
    }
  ],
  "maxReviewsPerHotel": 0,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call valiant_quarter/check24-hotel-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "CHECK24 Hotel Reviews Scraper",
        "description": "Scrape hotel reviews from CHECK24: customer ratings (1-10), verified feedback text, travel dates, traveler type info, and detailed guest insights — all as structured JSON.",
        "version": "1.0",
        "x-build-id": "qb3lQTaxhnVQ5pssy"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/valiant_quarter~check24-hotel-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-valiant_quarter-check24-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/valiant_quarter~check24-hotel-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-valiant_quarter-check24-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/valiant_quarter~check24-hotel-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-valiant_quarter-check24-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": "Hotel URLs",
                        "type": "array",
                        "description": "CHECK24 hotel URLs. Extract the clusterId from the URL path (e.g., 8914316 from /search/Hotel-Name-8914316/hotel.html)",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxReviewsPerHotel": {
                        "title": "Max reviews per hotel",
                        "minimum": 0,
                        "maximum": 50000,
                        "type": "integer",
                        "description": "Maximum number of reviews to scrape per hotel (ordered by relevance). Use 0 to scrape all reviews.",
                        "default": 0
                    },
                    "dateFrom": {
                        "title": "Review date from",
                        "pattern": "^$|^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Only include reviews published on or after this date (YYYY-MM-DD). Leave empty for no lower limit."
                    },
                    "dateTo": {
                        "title": "Review date to",
                        "pattern": "^$|^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Only include reviews published on or before this date (YYYY-MM-DD). Leave empty for no upper limit."
                    },
                    "includeRawData": {
                        "title": "Include raw data",
                        "type": "boolean",
                        "description": "Attach the raw API payload for each review under the `raw` key.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy settings. CHECK24 API works with datacenter IPs; Apify automatic proxy is recommended.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```