# Kununu Reviews Scraper — Employee Ratings & Feedback (`khadinakbar/kununu-reviews-scraper`) Actor

Scrape public Kununu employer reviews for DACH employer-brand monitoring, recruiting intelligence, and culture research. Returns individual review records with ratings, text, dates, recommendation signals, and company context for analytics and AI agents.

- **URL**: https://apify.com/khadinakbar/kununu-reviews-scraper.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** Jobs, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $25.00 / 1,000 kununu review extracteds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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/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

## Kununu Reviews Scraper — Employee Ratings & Feedback

Extract public Kununu employer reviews into structured JSON for DACH employer-brand monitoring, recruiting intelligence, culture research, and AI-agent workflows. Each dataset item is one public employee review with company context, rating, title, text, date, and a recommendation signal when Kununu displays it.

Use this actor for public employer review pages on `kununu.com`. It is designed as a focused public-review workflow alongside job, salary, and account-specific data tools.

### Best fit

Use direct Kununu `/kommentare` URLs when you want a reproducible view of public employee feedback. This works well for tracking a company over time, comparing competitor sentiment, or supplying compact evidence to a recruiting or employer-brand analysis workflow.

For Glassdoor-specific reviews, continue with the [Glassdoor Reviews Scraper](https://apify.com/khadinakbar/glassdoor-reviews-scraper) when you need a cross-platform employer comparison. For ratings from local customers rather than employees, continue with the [Google Maps Reviews Scraper](https://apify.com/khadinakbar/google-maps-reviews-scraper).

### Workflow story

An employer-brand team starts with the canonical Kununu review URL for a company it monitors. It collects a bounded review sample, then groups `rating`, `reviewText`, and `recommended` by month to identify recurring themes. Next, it passes the preserved `sourceUrl` and `scrapedAt` values to its internal report so every conclusion stays traceable to the public source page.

### Input

```json
{
    "companyUrls": ["https://www.kununu.com/at/kununu/kommentare"],
    "maxReviewsPerCompany": 25,
    "maxResults": 50,
    "ratingFilter": "all",
    "responseFormat": "detailed"
}
````

`companyUrls` accepts public German, Austrian, and Swiss Kununu employer review pages. `maxResults` is a global cap and also bounds the number of billable review events. The actor collects pages in their public page order; use `ratingFilter` to retain scores rounded to one whole rating after extraction.

### Output

```json
{
    "recordType": "review",
    "reviewId": "123ba638-1ded-4a7b-886c-26f26c7798b5",
    "companyName": "Example GmbH",
    "companyUrl": "https://www.kununu.com/at/example/kommentare",
    "companyRating": 4.2,
    "companyReviewCount": 16,
    "rating": 4,
    "reviewTitle": "Very good team",
    "reviewText": "Helpful colleagues. Clear feedback.",
    "author": "anonymous",
    "reviewDate": "2026-07-01T00:00:00.000Z",
    "recommended": true,
    "sourceUrl": "https://www.kununu.com/at/example/kommentare",
    "scrapedAt": "2026-07-19T14:17:21.000Z"
}
```

The dataset contains only review rows. The default key-value store holds `OUTPUT` and `RUN_SUMMARY`, each with a machine-readable `outcome`: `COMPLETE`, `PARTIAL`, `VALID_EMPTY`, `INVALID_INPUT`, or `UPSTREAM_FAILED`.

| Field                       | Use in analysis                                     |
| --------------------------- | --------------------------------------------------- |
| `rating`                    | Measure individual employee sentiment.              |
| `reviewText`                | Identify recurring culture and workplace themes.    |
| `recommended`               | Compare recommendation signals when publicly shown. |
| `sourceUrl` and `scrapedAt` | Preserve provenance and collection time.            |

### API example

```bash
curl -X POST 'https://api.apify.com/v2/acts/khadinakbar~kununu-reviews-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'content-type: application/json' \
  -d '{
    "companyUrls": ["https://www.kununu.com/at/kununu/kommentare"],
    "maxReviewsPerCompany": 10,
    "maxResults": 10
  }'
```

Replace `YOUR_APIFY_TOKEN` with an environment-managed token and keep it in your secure secret store.

### Pricing

This actor uses **Pay per event + platform usage**:

| Event                   |                    Price |
| ----------------------- | -----------------------: |
| Actor start             |         $0.00005 per run |
| Kununu review extracted | $0.025 per unique review |

The user also pays underlying Apify platform usage. The Actor charges only for unique review rows, while status-summary records are unbilled. Consult the live Pricing tab for the current effective price and platform-usage configuration before scheduling a large collection.

### Best-results guidance

- Provide the canonical `/kommentare` page for each company.
- Start with a small review sample to validate a company and output shape, then raise the cap for longitudinal analysis.
- Keep the default DACH residential proxy settings, which are designed for Kununu's CloudFront-delivered pages.
- Treat public review content as point-in-time feedback. Preserve the `sourceUrl` and `scrapedAt` fields when sharing an analysis.

### AI-agent prompt card

> As an AI agent, fetch a bounded set of public Kununu employee reviews for the supplied company review URL. Return the company rating, review count, individual star rating, title, text, date, recommendation signal, source URL, and collection time. Read back `OUTPUT.outcome` before drawing a sentiment conclusion and report the configured cost scope.

### Builder's note

I designed this actor around Kununu's public, server-rendered structured review content rather than a private endpoint. That makes provenance visible in each dataset row and keeps the contract focused on public employer reviews. The actor records an explicit outcome and machine-readable summary alongside the review dataset, which makes downstream monitoring and data-quality checks straightforward.

### Legal and responsible use

Only collect and process public data you are allowed to access and use. You are responsible for complying with Kununu's terms, applicable privacy and employment laws, copyright/database-right restrictions, and any obligations around sharing or profiling employee-review content.

# Actor input Schema

## `companyUrls` (type: `array`):

Public Kununu employer review-page URLs, for example 'https://www.kununu.com/at/kununu/kommentare'. Use the /kommentare page for each company. The actor accepts kununu.com pages in Germany, Austria, or Switzerland; it does not scrape jobs, salary pages, login-only pages, or private profiles.

## `maxReviewsPerCompany` (type: `integer`):

Maximum individual review rows to collect from each company URL. The default is 25 and the hard limit is 1,000. Lower values make a fast recent sample; higher values follow Kununu pagination until the company has no more public reviews. This is a review cap, not a page cap.

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

Maximum review rows saved across the full run. The default is 50 and the hard limit is 5,000. The actor stops before collecting beyond this cap, which also bounds per-review charges. This excludes run summaries in key-value storage because those are never dataset rows.

## `ratingFilter` (type: `string`):

Keep reviews nearest to one whole Kununu rating, or keep every visible review with 'all'. For example, '3' keeps public scores that round to 3 and '5' keeps scores that round to 5. Defaults to 'all'. This is applied after extraction and does not change Kununu's own page ordering.

## `responseFormat` (type: `string`):

Choose detailed or concise records for analytics and AI-agent workflows. Detailed returns all available company context and recommendation signals. Concise keeps the company, rating, title, text, date, and source fields for smaller records. Defaults to detailed; neither mode invents fields Kununu does not show publicly.

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

Apify proxy settings for Kununu requests. It defaults to a German residential session because employer pages are DACH-focused and protected through CloudFront. Leave the default for normal runs. This is not for account credentials, cookies, or a private Kununu login.

## Actor input object example

```json
{
  "companyUrls": [
    "https://www.kununu.com/at/kununu/kommentare"
  ],
  "maxReviewsPerCompany": 10,
  "maxResults": 10,
  "ratingFilter": "all",
  "responseFormat": "detailed",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "DE"
  }
}
```

# Actor output Schema

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

No description

## `output` (type: `string`):

No description

## `runSummary` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "companyUrls": [
        "https://www.kununu.com/at/kununu/kommentare"
    ],
    "maxReviewsPerCompany": 10,
    "maxResults": 10,
    "ratingFilter": "all",
    "responseFormat": "detailed",
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "DE"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/kununu-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 = {
    "companyUrls": ["https://www.kununu.com/at/kununu/kommentare"],
    "maxReviewsPerCompany": 10,
    "maxResults": 10,
    "ratingFilter": "all",
    "responseFormat": "detailed",
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "DE",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/kununu-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 '{
  "companyUrls": [
    "https://www.kununu.com/at/kununu/kommentare"
  ],
  "maxReviewsPerCompany": 10,
  "maxResults": 10,
  "ratingFilter": "all",
  "responseFormat": "detailed",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "DE"
  }
}' |
apify call khadinakbar/kununu-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Kununu Reviews Scraper — Employee Ratings & Feedback",
        "description": "Scrape public Kununu employer reviews for DACH employer-brand monitoring, recruiting intelligence, and culture research. Returns individual review records with ratings, text, dates, recommendation signals, and company context for analytics and AI agents.",
        "version": "1.0",
        "x-build-id": "txAhocQCYJ9Fx2uBr"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/khadinakbar~kununu-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-khadinakbar-kununu-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/khadinakbar~kununu-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-khadinakbar-kununu-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/khadinakbar~kununu-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-khadinakbar-kununu-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": [
                    "companyUrls"
                ],
                "properties": {
                    "companyUrls": {
                        "title": "Kununu employer review URLs",
                        "type": "array",
                        "description": "Public Kununu employer review-page URLs, for example 'https://www.kununu.com/at/kununu/kommentare'. Use the /kommentare page for each company. The actor accepts kununu.com pages in Germany, Austria, or Switzerland; it does not scrape jobs, salary pages, login-only pages, or private profiles.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxReviewsPerCompany": {
                        "title": "Maximum reviews per company",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum individual review rows to collect from each company URL. The default is 25 and the hard limit is 1,000. Lower values make a fast recent sample; higher values follow Kununu pagination until the company has no more public reviews. This is a review cap, not a page cap.",
                        "default": 25
                    },
                    "maxResults": {
                        "title": "Maximum total reviews",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum review rows saved across the full run. The default is 50 and the hard limit is 5,000. The actor stops before collecting beyond this cap, which also bounds per-review charges. This excludes run summaries in key-value storage because those are never dataset rows.",
                        "default": 50
                    },
                    "ratingFilter": {
                        "title": "Star rating filter",
                        "enum": [
                            "all",
                            "5",
                            "4",
                            "3",
                            "2",
                            "1"
                        ],
                        "type": "string",
                        "description": "Keep reviews nearest to one whole Kununu rating, or keep every visible review with 'all'. For example, '3' keeps public scores that round to 3 and '5' keeps scores that round to 5. Defaults to 'all'. This is applied after extraction and does not change Kununu's own page ordering.",
                        "default": "all"
                    },
                    "responseFormat": {
                        "title": "Response format",
                        "enum": [
                            "detailed",
                            "concise"
                        ],
                        "type": "string",
                        "description": "Choose detailed or concise records for analytics and AI-agent workflows. Detailed returns all available company context and recommendation signals. Concise keeps the company, rating, title, text, date, and source fields for smaller records. Defaults to detailed; neither mode invents fields Kununu does not show publicly.",
                        "default": "detailed"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify proxy settings for Kununu requests. It defaults to a German residential session because employer pages are DACH-focused and protected through CloudFront. Leave the default for normal runs. This is not for account credentials, cookies, or a private Kununu login.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "apifyProxyCountry": "DE"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
