# Kununu Reviews Scraper Cheap (`data_api/kununu-reviews-scraper-cheap`) Actor

Kununu reviews scraper that pulls employee ratings, pros, cons, and written feedback from any company page on kununu.com, so you can track what people actually say about an employer without reading through pages manually.

- **URL**: https://apify.com/data\_api/kununu-reviews-scraper-cheap.md
- **Developed by:** [Data API](https://apify.com/data_api) (community)
- **Categories:** Automation, Developer tools, Jobs
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.99 / 1,000 results

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## Kununu Employer Reviews Scraper

![Kununu Employer Reviews Scraper](cover.jpg)

Kununu holds thousands of first-hand employee reviews for German-speaking employers, but the site spreads them across paginated pages with no clean way to download them. Reading review pages one screen at a time stops being practical the moment you want to compare companies or track sentiment over a quarter. This scraper does the clicking for you. Paste a Kununu reviews URL and it walks every page, pulls the star rating, headline, pros, cons, suggestions, and the reviewer's role, then hands each review back as one tidy row. Point it at a single employer or feed it a whole list.

### What you get

Every review becomes one row with the same set of columns, and anything Kununu does not show comes back as `null` so your table stays rectangular when you load it into a sheet or database. Each row groups into:

- **Employer context** — `employerName`, `employerSlug`, `employerUrl`
- **The review itself** — `reviewKey`, `starRating`, `reviewHeadline`, `wouldRecommend`, `positivePoints`, `negativePoints`, `improvementNotes`, `reviewLink`, `postedDate`
- **Who wrote it** — `departmentArea`, `workerCategory`, `tenureStatus`
- **Run metadata** — `collectedAt`, `errorMessage`

### Quick start

1. Click **Try for free** and open the input form.
2. Paste a Kununu reviews URL into **Employer review page URL**, or drop several links into **Several employer URLs**.
3. Set a **Review cap per employer** if you want to limit how many reviews come back.
4. Press **Start**, then download the results as JSON, CSV, Excel, or XML once the run finishes.

![How it works](how-it-works.jpg)

### Use cases

- **Employer branding** — track how your own ratings, pros, and cons shift over time and react before sentiment turns
- **Competitive benchmarking** — line up several employers side by side on star ratings and recurring complaints
- **HR and recruiting research** — read what current and former staff say about pay, management, and culture before you pitch candidates
- **Market and consultancy reports** — pull a clean dataset of reviews to fold into employer surveys or workplace studies
- **Sentiment and NLP projects** — feed the pros, cons, and headlines into your own text-analysis pipeline

### Input

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `employerPageUrl` | string | One of `employerPageUrl` or `employerPageUrls` | A single Kununu employer reviews URL. The `/kommentare` ending is added for you if it is missing. |
| `employerPageUrls` | array of strings | Optional | A list of Kununu employer reviews URLs to cover several employers in one run. |
| `resultsLimit` | integer | No | Most reviews to gather per employer. Collection stops once the cap is reached. Default `50`. |
| `timeoutSeconds` | integer | No | Seconds to wait on each request before timing out. Default `45`; raise it if requests keep timing out. |

#### Example input

```json
{
    "employerPageUrl": "https://www.kununu.com/de/bosch/kommentare",
    "employerPageUrls": [
        "https://www.kununu.com/de/bosch/kommentare",
        "https://www.kununu.com/de/sap/kommentare",
        "https://www.kununu.com/de/allianz/kommentare"
    ],
    "resultsLimit": 50,
    "timeoutSeconds": 45
}
````

### Output

Each review becomes one row, and every field is always present — values Kununu does not expose come back as `null` so the dataset stays consistent.

#### Example output

```json
{
    "reviewKey": "3f2a9c1e-7b4d-4e2a-9c5f-1a2b3c4d5e6f",
    "employerName": "Robert Bosch GmbH",
    "employerSlug": "bosch",
    "employerUrl": "https://www.kununu.com/de/bosch/kommentare",
    "starRating": 4.2,
    "reviewHeadline": "Solider Arbeitgeber mit guten Entwicklungsmöglichkeiten",
    "wouldRecommend": "Empfohlen",
    "positivePoints": "Faires Gehalt, flexible Arbeitszeiten und ein starkes Team.",
    "negativePoints": "Entscheidungswege sind manchmal langsam.",
    "improvementNotes": "Mehr Transparenz bei Beförderungen wäre wünschenswert.",
    "departmentArea": "Forschung / Entwicklung",
    "workerCategory": "Angestellte/r oder Arbeiter/in",
    "tenureStatus": "Current employee",
    "postedDate": "2025-11-18T00:00:00+00:00",
    "reviewLink": "https://www.kununu.com/de/bosch/kommentare/statements/abc123/review/3f2a9c1e",
    "collectedAt": "2026-06-29T12:00:00.000000+00:00",
    "errorMessage": null
}
```

#### Output fields

| Field | Type | Description |
|-------|------|-------------|
| `reviewKey` | string | The review's own UUID, unique to each entry |
| `employerName` | string | Name of the reviewed employer |
| `employerSlug` | string | The employer's URL slug, such as bosch |
| `employerUrl` | string | Kununu reviews page that was visited |
| `starRating` | number | Rating given in the review, on a 1.0 to 5.0 scale |
| `reviewHeadline` | string | Title the reviewer chose for their write-up |
| `wouldRecommend` | string | Whether the reviewer endorses the employer, e.g. Empfohlen or Nicht empfohlen |
| `positivePoints` | string | Upsides the reviewer called out |
| `negativePoints` | string | Downsides the reviewer flagged |
| `improvementNotes` | string | Suggestions the reviewer offered for improvement |
| `departmentArea` | string | Team or area the reviewer worked in |
| `workerCategory` | string | Reviewer's role bucket as listed on Kununu |
| `tenureStatus` | string | Whether the reviewer is a current or former employee |
| `postedDate` | string | When the review was posted, ISO 8601 format |
| `reviewLink` | string | Direct URL to the single review on Kununu |
| `collectedAt` | string | ISO 8601 timestamp of when the row was captured |
| `errorMessage` | string | Reason a record failed; `null` on success |

### Tips for best results

- **Test with a small cap first.** Set `resultsLimit` to 20 or so on one employer, confirm the output fits your pipeline, then raise it for the full pull.
- **Use the list field for batches.** Drop several URLs into `employerPageUrls` to gather multiple employers in a single run instead of starting one job per company.
- **A bare profile URL works too.** Leave off `/kommentare` and the scraper appends it, so a plain employer link is fine.
- **Raise `timeoutSeconds` if pages run slow.** Long review pages and busy periods can stretch response times; 60 seconds gives heavier pages room to load.
- **Reviews are mostly in German.** Kununu's content reflects its German-speaking audience, so headlines, pros, and cons usually come back in German.

### How can I use Kununu employer review data?

**How can I use the Kununu Employer Reviews Scraper to benchmark companies against competitors?**
Drop the reviews URLs for your company and a few rivals into `employerPageUrls` and run them together. Each review comes back with a star rating, pros, cons, and the reviewer's role, so you can average ratings per employer and compare recurring praise or complaints across the group in one dataset.

**How can I track employer reputation on Kununu over time?**
Run the scraper on the same employer URL on a regular schedule and keep each export. Because every row carries a `postedDate` and `starRating`, you can chart how sentiment moves month to month and catch a dip in ratings or a wave of new complaints early.

**How can I export Kununu reviews for HR research or sentiment analysis?**
Set `resultsLimit` to the number you need and let the scraper page through the employer's reviews. The `positivePoints`, `negativePoints`, `improvementNotes`, and `reviewHeadline` fields give you clean text to feed straight into a spreadsheet, a survey report, or an NLP model — no copy-pasting from the site.

### Is it legal to scrape data?

Our actors are ethical and do not extract any private user data, such as email addresses or private contact information. They only extract what the user has chosen to share publicly. We therefore believe that our actors, when used for ethical purposes by Apify users, are safe.

However, you should be aware that your results could contain personal data. Personal data is protected by the GDPR in the European Union and by other regulations around the world. You should not scrape personal data unless you have a legitimate reason to do so. If you're unsure whether your reason is legitimate, consult your lawyers.

You can also read Apify's blog post on the [legality of web scraping](https://blog.apify.com/is-web-scraping-legal/).

### Support

Questions, feature requests, or a field you'd like added? Reach out at <data.apify@proton.me> and we'll get back to you.

# Actor input Schema

## `employerPageUrl` (type: `string`):

Address of a Kununu employer's reviews page. If the /kommentare ending is left off, it gets appended for you.

## `employerPageUrls` (type: `array`):

A batch of Kununu employer review page links. Reach for this field when you want more than one employer in the same run.

## `resultsLimit` (type: `integer`):

Largest number of reviews to gather for each employer URL. Collection halts as soon as the cap is hit.

## `timeoutSeconds` (type: `integer`):

How long to wait on a single request before giving up. Bump this up if requests keep timing out.

## Actor input object example

```json
{
  "employerPageUrl": "https://www.kununu.com/de/sap/kommentare",
  "employerPageUrls": [
    "https://www.kununu.com/de/bosch/kommentare",
    "https://www.kununu.com/de/sap/kommentare",
    "https://www.kununu.com/de/allianz/kommentare"
  ],
  "resultsLimit": 50,
  "timeoutSeconds": 45
}
```

# 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 = {
    "employerPageUrl": "https://www.kununu.com/de/bosch/kommentare"
};

// Run the Actor and wait for it to finish
const run = await client.actor("data_api/kununu-reviews-scraper-cheap").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 = { "employerPageUrl": "https://www.kununu.com/de/bosch/kommentare" }

# Run the Actor and wait for it to finish
run = client.actor("data_api/kununu-reviews-scraper-cheap").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 '{
  "employerPageUrl": "https://www.kununu.com/de/bosch/kommentare"
}' |
apify call data_api/kununu-reviews-scraper-cheap --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Kununu Reviews Scraper Cheap",
        "description": "Kununu reviews scraper that pulls employee ratings, pros, cons, and written feedback from any company page on kununu.com, so you can track what people actually say about an employer without reading through pages manually.",
        "version": "0.0",
        "x-build-id": "aWkyG3iMbA8yVxhFG"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/data_api~kununu-reviews-scraper-cheap/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-data_api-kununu-reviews-scraper-cheap",
                "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/data_api~kununu-reviews-scraper-cheap/runs": {
            "post": {
                "operationId": "runs-sync-data_api-kununu-reviews-scraper-cheap",
                "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/data_api~kununu-reviews-scraper-cheap/run-sync": {
            "post": {
                "operationId": "run-sync-data_api-kununu-reviews-scraper-cheap",
                "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",
                "properties": {
                    "employerPageUrl": {
                        "title": "Employer review page URL",
                        "type": "string",
                        "description": "Address of a Kununu employer's reviews page. If the /kommentare ending is left off, it gets appended for you."
                    },
                    "employerPageUrls": {
                        "title": "Several employer URLs",
                        "type": "array",
                        "description": "A batch of Kununu employer review page links. Reach for this field when you want more than one employer in the same run.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "resultsLimit": {
                        "title": "Review cap per employer",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Largest number of reviews to gather for each employer URL. Collection halts as soon as the cap is hit.",
                        "default": 50
                    },
                    "timeoutSeconds": {
                        "title": "Request timeout (seconds)",
                        "minimum": 5,
                        "maximum": 120,
                        "type": "integer",
                        "description": "How long to wait on a single request before giving up. Bump this up if requests keep timing out.",
                        "default": 45
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
