# Kununu Scraper \[from $1💰] | Employer Reviews DE/AT/CH (`ahmed_jasarevic/kununu-scraper`) Actor

Scrape kununu.com employer reviews and ratings for DACH companies - overall and per-category scores, pros/cons/suggestions, reviewer details and company aggregates for HR research, employer brand monitoring and recruitment intelligence.

- **URL**: https://apify.com/ahmed\_jasarevic/kununu-scraper.md
- **Developed by:** [Ahmed Jasarevic](https://apify.com/ahmed_jasarevic) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.97 / 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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Kununu Scraper — DACH Employer Reviews & Ratings

Extract kununu.com employer reviews and ratings for any DACH company — overall and per-category scores, pros/cons/suggestions, reviewer details and company aggregates — as clean structured JSON through kununu's own data endpoints. This is the cheapest pay-per-result Kununu scraper on the Apify Store (from ~$0.001 per review), built for employer brand monitoring, HR research and recruitment intelligence.

### Main Use Cases

- **Employer review monitoring** — track your company's kununu Score, recommendation rate and category scores over time.
- **HR & recruitment intelligence** — check what employees and candidates say before you hire, partner or apply.
- **Employer branding & reputation management** — surface recurring complaints and praise without reading hundreds of pages.
- **Competitor benchmarking** — compare employer ratings across companies in the same industry before making decisions.
- **Labor-market research** — build large-scale DACH employer review datasets for academic or market analysis.
- **Candidate experience analysis** — evaluate interview and application feedback from candidate reviews.

### Extract Kununu Employer Reviews for DACH Companies

Kununu is the leading employer-review platform in the German-speaking market (Germany, Austria, Switzerland — DE, AT, CH) and part of New Work SE. kununu reports over 15 million workplace insights, including 4 million+ employer reviews. This actor turns those public reviews into a structured dataset you can query, filter and analyze.

Point it at one or more company profiles and it returns two row types:

- **Company aggregate rows** — one per company: overall score, total review count, recommendation rate, recommended/not-recommended counts, score ranges, factor scores and category scores.
- **Review rows** — one per review: headline, overall rating, recommendation flag, date, employment status, former-employee flag, department, location, pros/cons/suggestions, per-category ratings, reactions and employer responses.

### Monitor Employer Ratings Without an Official Kununu API

Kununu does not offer an official public API, and its pages sit behind AWS CloudFront and AWS WAF, which block datacenter IPs and automated browsers. This actor solves both problems:

- It reads kununu's own JSON data endpoints — the same ones the kununu website uses internally — so there is no HTML parsing and no browser overhead.
- It solves AWS WAF JS-challenge tokens per residential proxy session and retries blocked requests automatically (up to 8 attempts) from fresh German residential IPs.
- Each company is scraped in one warm session (same IP + cookies), mimicking a real visitor so the WAF rate limiter does not kick in.

The result: a fast, lightweight HTTP scraper (no browser, no login) that is significantly cheaper per review than browser-based crawlers.

### Export Review Data for HR Analytics and Employer Brand Research

Everything the actor collects lands in an Apify dataset that you can download as JSON, CSV, HTML or Excel, or pull programmatically via the Apify API. Typical research workflows:

- Aggregate pros/cons themes across hundreds of reviews per company.
- Slice reviews by department, location or employment status.
- Compare category scores (work-life balance, salary, career, culture) between companies.
- Feed review rows into BI dashboards, Power BI, Excel or Python/pandas pipelines.

### Input Configuration

| Field | Type | Required | Default | Notes |
| ----- | ---- | -------- | ------- | ----- |
| `companyUrls` | array | ✅ | `["https://www.kununu.com/de/sap"]` | Kununu profile URLs (`https://www.kununu.com/de/sap`), country-prefixed slugs (`at/red-bull`), or bare slugs (`sap`). DE, AT and CH can be mixed in one run. |
| `maxReviewsPerCompany` | integer | — | `50` | Upper limit of reviews collected per company (10 per API page). Free accounts get a capped preview of 10 per company. |
| `reviewType` | string | — | `all` | Which reviewer group to collect: `all` (employees + candidates), `employees`, or `candidates`. |
| `includeCompanyAggregates` | boolean | — | `true` | Emit a company row with overall score, review counts, recommendation rate and category scores. |
| `maxItems` | integer | — | `200` | Hard cap on total dataset rows — your main cost control. |
| `proxyConfiguration` | object | — | `{ "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"], "apifyProxyCountry": "de" }` | Apify proxy selector. kununu is behind AWS WAF and blocks datacenter + non-EU IPs, so keep Apify Proxy on, use `RESIDENTIAL` and a German IP. |

### Output Fields

**Review rows** (`type: "review"`):

| Field | Type | Description |
| ----- | ---- | ----------- |
| `reviewId` | string | Unique review identifier (UUID) |
| `companySlug` / `companyCountry` | string | Company profile slug and country (`de` / `at` / `ch`) |
| `companyName` | string | Display name of the company |
| `reviewTitle` | string | Headline written by the reviewer |
| `overallRating` | number | Overall star rating (1.0 to 5.0) |
| `recommended` | boolean | Whether the reviewer recommends the employer |
| `reviewDate` | string | Date the review was posted (ISO 8601) |
| `employmentStatus` | string | Reviewer group (e.g. `employee`, `manager`, `student`) |
| `isFormerEmployee` | boolean | Whether the reviewer is a former employee |
| `department` | string | Department the reviewer worked in |
| `location` | string | City of the reviewed location |
| `pros` / `cons` / `suggestions` | string | Free-text review sections ("Was mir am Arbeitgeber gefällt", "Schlecht am Arbeitgeber", "Verbesserungsvorschläge") |
| `categoryRatings` | object | Per-category scores and comments (work-life balance, salary, culture, career…) |
| `reactions` | object | Reaction counts (e.g. helpful) |
| `employerResponses` | array | HR responses to the review |
| `reviewUrl` | string | Canonical URL of the review on kununu |

**Company aggregate rows** (`type: "company"`):

| Field | Type | Description |
| ----- | ---- | ----------- |
| `profileUrl` | string | Canonical kununu company profile URL |
| `companyId` | string | Kununu company UUID |
| `overallScore` | number | Overall kununu score (e.g. 4.1) |
| `totalReviews` | number | Total review count shown on the profile |
| `recommendationRate` | number | Share of reviewers who recommend the employer (%) |
| `recommendedTotalReviews` / `notRecommendedTotalReviews` | number | Recommended / not-recommended review counts |
| `scoreRanges` | array | Score distribution buckets |
| `factorScores` | array | Per-factor scores (id, categoryId, score, roundedScore, totalReviews) |
| `categoryScores` | object | Category → { score, totalReviews } map |

### Example Input

```json
{
    "companyUrls": [
        "https://www.kununu.com/de/sap",
        "at/red-bull",
        "sap"
    ],
    "maxReviewsPerCompany": 100,
    "reviewType": "all",
    "includeCompanyAggregates": true,
    "maxItems": 250,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "DE"
    }
}
```

### Example Output

**Company aggregate row:**

```json
{
    "type": "company",
    "companySlug": "sap",
    "companyCountry": "de",
    "profileUrl": "https://www.kununu.com/de/sap",
    "companyId": "a558284b-93ad-4015-a649-a1e152c479c8",
    "overallScore": 4.1,
    "totalReviews": 4671,
    "recommendationRate": 91,
    "recommendedTotalReviews": 4251,
    "notRecommendedTotalReviews": 420,
    "scoreRanges": [],
    "factorScores": [
        { "id": "workLifeBalance", "categoryId": "workLife", "score": 4.0, "roundedScore": 4.0, "totalReviews": 4510 }
    ],
    "categoryScores": {}
}
```

**Review row:**

```json
{
    "type": "review",
    "reviewId": "80195042-b1aa-461d-9bed-5299f182295f",
    "companySlug": "sap",
    "companyCountry": "de",
    "companyName": "SAP SE",
    "reviewTitle": "Die Work-Life-Balance ist gut, aber ...",
    "overallRating": 3.5,
    "recommended": true,
    "reviewDate": "2026-08-01T00:00:00.000Z",
    "employmentStatus": "employee",
    "isFormerEmployee": false,
    "department": "it",
    "location": "Walldorf",
    "pros": "Flexible Arbeitszeiten ...",
    "cons": "Hohe Arbeitsbelastung ...",
    "suggestions": "Mehr Transparenz ...",
    "categoryRatings": { "workLifeBalance": { "score": 4.0, "text": "..." } },
    "reactions": { "helpful": { "count": 3 } },
    "employerResponses": [],
    "reviewUrl": "https://www.kununu.com/de/sap/bewertung/80195042-b1aa-461d-9bed-5299f182295f"
}
```

### Scrape Kununu Data Through AWS WAF (How It Works)

1. Submit one or more kununu company URLs or slugs. The actor resolves each one through kununu's public company search middleware to find the correct profile in the right country.
2. For each company it opens one warm session (same IP + cookies) and paginates kununu's review and profile data endpoints — 10 reviews per API page.
3. If the AWS WAF throws a JS challenge, the actor solves the WAF token for that session and retries from a fresh residential IP (up to 8 attempts). DACH residential IPs are trusted most by the WAF.
4. Results stream to the Apify dataset in seconds for small batches. Company aggregate rows are emitted first (if enabled), followed by review rows in pagination order.

### Integrations & Automation

Every run is callable through the **Apify API**, so you can:

- **Schedule daily or weekly runs** in Apify Console — ideal for employer review monitoring and reputation tracking.
- **Chain with webhooks** — trigger workflows when a run finishes (e.g. Slack alert when your kununu Score changes).
- **Connect to no-code tools** — Apify's built-in integrations make the actor available in Make, Zapier and n8n.
- **Consume results programmatically** via the Apify client libraries for JavaScript, Python and more.

**Recommended schedule:** run weekly for employer brand monitoring; run on-demand for HR due-diligence research. Recurring usage also keeps your dataset fresh and strengthens Apify Store recommendations.

### Frequently Asked Questions About Scraping Kununu

#### Does kununu have an official API?

No. Kununu does not offer a public, self-service API. Company data and reviews are only accessible through the website and the data endpoints behind it. This actor provides programmatic access to that public data without an official API.

#### Why use this actor instead of the official API?

There is no self-service kununu API. The closest official options (employer branding products) are partner/sales-led and do not expose review exports. This actor gives instant, pay-per-result API access to public kununu reviews, scores and company aggregates — with no partner application and no login.

#### Is scraping kununu legal?

Scraping publicly available employer reviews for research and analysis is generally considered acceptable, but you are responsible for complying with kununu's Terms of Service and applicable data-protection laws (e.g. GDPR for EU personal data) when using the data. See the Legal & Compliance Disclaimer below.

#### Kununu vs Glassdoor — which has more DACH reviews?

For German-speaking employers, kununu is the dominant review platform — kununu states 4 million+ employer reviews and 15 million+ workplace insights across Germany, Austria and Switzerland, and reviews are written in German natively. Glassdoor's coverage in DACH is thinner and its official API is a restricted partner program. If you also need US/global employer review data, combine this actor with a Glassdoor scraper (see Related Actors).

#### What are alternatives to this actor / this data source?

- **Other Apify actors** for kununu (see Related Actors below) and Glassdoor / Indeed employer review scrapers.
- **Manual browsing** of kununu company pages — slow and unscalable for hundreds of companies.
- **SaaS "kununu API" proxies** — typically priced per request with monthly fees and lower limits.

#### How many reviews does kununu have?

Kununu's own figures: over 15 million workplace insights, including more than 4 million employer reviews, growing by roughly 10,800 employer reviews per week (as published on kununu.com).

#### Can I scrape both employee and candidate reviews?

Yes. Set `reviewType` to `all` (default) to collect both, or restrict to `employees` or `candidates`. With `all`, the per-company budget is split between the two groups.

#### How much does it cost to scrape kununu?

The actor is pay-per-event: roughly **$0.001 per dataset row** (~$0.00097 on higher Apify plans) plus a small run-start fee (about $0.0002 per run at default 4 GB memory). Remember `maxItems` is your hard cost cap. Free Apify accounts get a preview of 10 reviews per company.

#### Can I monitor my kununu employer rating over time?

Yes. Schedule the actor daily or weekly in Apify Console and combine the company aggregate rows over time to chart the kununu Score, recommendation rate and category scores — full reputation monitoring without manual page visits.

#### What countries does this kununu scraper cover?

Germany (de), Austria (at) and Switzerland (ch). You can mix countries in a single run, e.g. `https://www.kununu.com/de/sap` and `https://www.kununu.com/at/red-bull`.

### Related Actors

- [Glassdoor Reviews & Jobs · No 200-Cap · AI Employer Intel](https://apify.com/memo23/glassdoor-scraper-ppr) — the largest employer-review actor on Apify; covers Glassdoor reviews, jobs and salaries.
- [Glassdoor Reviews Scraper](https://apify.com/getdataforme/glassdoor-reviews-scraper) — extracts authentic Glassdoor employee reviews for company culture, compensation and work-life balance research.
- [Kununu.com Companies Scraper](https://apify.com/lexis-solutions/kununu-scraper) — another kununu company/review data actor for cross-checking DACH employer data.
- [Kununu Scraper · DACH Employer Reviews, Salaries & Jobs](https://apify.com/memo23/kununu-scraper) — kununu data with salary tables, job postings and contact-email enrichment.
- [Indeed Employer Intelligence](https://apify.com/bovi/indeed-employer-intelligence) — Indeed employer reviews, interview Q\&A and company dossiers for a broader reviews dataset.

### Competitive Positioning

Verified against the kununu actors currently listed on the Apify Store (BRONZE-tier prices from their public pricing pages):

| Capability | Other kununu actors on Apify | This actor |
| ---------- | ---------------------------- | ---------- |
| Price per review/row | $0.0038 – $0.0167 (e.g. automation-lab $0.0038364, data\_api $0.00466, kawsar $0.01667) | ~$0.001 (FREE tier), $0.00097+ on higher plans |
| Free preview plan | Varies | Capped preview: 10 reviews per company |
| DACH country coverage | Several actors cover DE/AT/CH | DE, AT, CH — mixed in one run |
| Technical approach | Browser/HTML parsing in most cases | kununu's JSON data endpoints + automatic AWS WAF token handling |

### SEO Keywords

kununu scraper, kununu reviews scraper, kununu API, kununu API alternative, kununu data export, kununu employer reviews dataset, kununu Bewertungen exportieren, Arbeitgeberbewertungen Scraper, employer review scraping, employer review data, employer review monitoring, employer brand monitoring, HR analytics, recruitment intelligence, DACH employer reviews, German employer reviews, Arbeitgeberbewertungen Deutschland, kununu Score, kununu Österreich, Glassdoor alternative DACH, kununu candidate reviews, kununu ratings, employer reputation management, kununu review API

### For AI Agents & LLM Apps

This actor is callable via the Apify MCP server and the Apify REST API by other agents.

**Purpose:** Given one or more kununu company URLs/slugs, returns structured company aggregate + review rows (ratings, pros/cons, reviewer metadata, category scores) for DACH employers.

**Minimal working input:**

```json
{ "companyUrls": ["https://www.kununu.com/de/sap"], "maxItems": 100 }
```

**Variant inputs:**

```json
{ "companyUrls": ["sap"], "reviewType": "candidates", "maxReviewsPerCompany": 30, "includeCompanyAggregates": false, "maxItems": 90 }
```

**Output fields (dataset rows):** `type`, `reviewId`, `companySlug`, `companyCountry`, `companyName`, `reviewTitle`, `overallRating`, `recommended`, `reviewDate`, `employmentStatus`, `isFormerEmployee`, `department`, `location`, `pros`, `cons`, `suggestions`, `categoryRatings`, `reactions`, `employerResponses`, `reviewUrl` (review rows); `profileUrl`, `companyId`, `overallScore`, `totalReviews`, `recommendationRate`, `recommendedTotalReviews`, `notRecommendedTotalReviews`, `scoreRanges`, `factorScores`, `categoryScores` (company rows).

**Behaviors an agent should know:**

- `maxItems` is a hard cap on total dataset rows — always set it to bound cost. Unset it and the default (200) still applies.
- With `reviewType: "all"` (default), the per-company review budget is split roughly evenly between employee and candidate reviews.
- Free Apify accounts are limited to 10 reviews per company regardless of `maxReviewsPerCompany`; set it explicitly for predictability.
- `proxyConfiguration` defaults to Apify Proxy + `RESIDENTIAL` + country `DE`. Keep residential proxies on — kununu blocks datacenter IPs via AWS WAF.
- Company aggregate rows are only emitted when `includeCompanyAggregates` is `true` (default).
- Input accepts full URLs, country-prefixed slugs (`at/red-bull`) and bare slugs (`sap`); bare slugs are treated as Germany (`de`).
- Each company runs in one warm IP session; blocked requests are retried automatically with fresh residential IPs (up to 8 attempts).

**Billing:** pay-per-event. ~$0.001 per dataset row (less on higher Apify plans; ~$0.00097 GOLD) + a small run-start fee (~$0.0002 per run at 4096 MB memory). Use `maxItems` to cap a run's spend.

### Legal & Compliance Disclaimer

Kununu Scraper is an independent tool and is not affiliated with, endorsed by, or sponsored by kununu GmbH or New Work SE.

The actor only reads **publicly available** kununu company profiles and the public data endpoints behind them. It does not require or use any kununu account or login, and it does not solve CAPTCHAs. It does not extract personal contact data such as email addresses or phone numbers.

You are responsible for your own compliance with kununu's Terms of Service and applicable data-protection law when using the extracted data. Since reviews may contain EU personal data (names, roles, locations), process them in line with the GDPR. Do not use review content for harassment, defamation or retaliation against individual reviewers.

If you need help staying compliant, contact us via the Issues tab — custom solutions are available.

# Actor input Schema

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

Kununu company profile URLs (e.g. https://www.kununu.com/de/sap), country-prefixed slugs (at/red-bull) or bare slugs (sap). DE, AT and CH can be mixed in one run.

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

Upper limit of employee reviews collected per company (10 per API page).

## `reviewType` (type: `string`):

Which reviewer group to collect. 'all' fetches both employee and candidate reviews.

## `includeCompanyAggregates` (type: `boolean`):

Emit a company row with overall score, review counts, recommendation rate and category scores.

## `maxItems` (type: `integer`):

Hard cap on total dataset rows — your main cost control.

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

Proxy selection. kununu is behind AWS WAF and blocks datacenter + non-EU IPs, so keep Apify Proxy enabled, prefer the RESIDENTIAL group and use a German IP (apifyProxyCountry: de).

## Actor input object example

```json
{
  "companyUrls": [
    "https://www.kununu.com/de/sap"
  ],
  "maxReviewsPerCompany": 50,
  "reviewType": "all",
  "includeCompanyAggregates": true,
  "maxItems": 200,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "DE"
  }
}
```

# Actor output Schema

## `results` (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/de/sap"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "DE"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("ahmed_jasarevic/kununu-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/de/sap"],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "DE",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("ahmed_jasarevic/kununu-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).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/de/sap"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "DE"
  }
}' |
apify call ahmed_jasarevic/kununu-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,ahmed_jasarevic/kununu-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/7Ojw3heyyG5gQcPpG/builds/w0hytBQdLzc78nvfH/openapi.json