# Employer reviews, salaries & jobs (`reviewly/kunnu-scraper`) Actor

Scrapes employer reviews, salary ranges and job listings from kununu.com profiles across Germany, Austria and Switzerland.

- **URL**: https://apify.com/reviewly/kunnu-scraper.md
- **Developed by:** [Reviewly](https://apify.com/reviewly) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 reviews

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 — Employer Reviews, Salary Data & Jobs (Germany, Austria, Switzerland)

**Extract every employer review, salary range and job listing from any kununu company profile — the full archive, not just the first page.**

Kununu is the dominant employer-review platform in the DACH region, with millions of reviews on German, Austrian and Swiss companies. This Apify Actor turns any kununu profile into clean, structured JSON you can analyse, monitor or load straight into your own database.

- ✅ **Complete review history** — scrape back to a company's very first review (2008 for many profiles), not the 10 that kununu shows logged-out visitors
- ✅ **Three datasets in one run** — reviews, salary ranges and job listings per company
- ✅ **13 rated factors per review** — with the reviewer's own free-text comment on each
- ✅ **Bot protection handled for you** — kununu sits behind AWS WAF; the Actor clears it automatically
- ✅ **All of DACH** — `.com/de/`, `.com/at/` and `.com/ch/` profiles all supported

***

### 📌 What This Actor Does

This kununu scraper takes a list of company profile URLs (or just company names) and returns one structured record per company, containing the employer's headline reputation metrics plus three nested arrays: **reviews**, **salaries** and **jobs**.

It is built for people who need employer data at scale rather than one page at a time:

| You are… | You use it to… |
|---|---|
| **HR & People Analytics** | Benchmark your employer brand against direct competitors |
| **Talent Acquisition** | Track what candidates say about your hiring process |
| **Market researchers** | Analyse sentiment and pay across an industry or region |
| **Compensation teams** | Pull per-job-title salary ranges for DACH benchmarking |
| **Data teams & developers** | Feed employer data into dashboards, models or a warehouse |
| **Sales & lead generation** | Find companies hiring, growing, or with reputation problems |

No coding is required to run it. Developers can call it through the Apify API and get the same JSON.

***

### ✨ Key Features

- **Full review pagination.** With an account, the Actor walks every review page to the end of the archive — verified to page 242 on a 2,418-review profile.
- **Guaranteed newest-first ordering.** Reviews are always fetched in true chronological order, so "the 100 most recent reviews" means exactly that.
- **Rich review detail.** Overall score, recommendation flag, title, date, reviewer position and department, current/former status, city, employer replies, and helpful/agree counts.
- **13 rated factors with comments** — work atmosphere, image, work-life balance, career development, salary, environment, teamwork, leadership, working conditions, communication, equality, tasks and senior-colleague treatment — each with its own score and free text.
- **Positive / negative / suggestion blocks** captured separately for easy sentiment work.
- **Salary ranges by job title** — min, max, median, average in EUR gross annual, plus how many submissions back each range.
- **Job listings** with title, city, region, employment type, posting date, link and kununu's salary benchmark for that role.
- **Company profile metrics** — overall score, industry average, recommendation rate, review counts, Top Company awards, headquarters, employee count, benefits with percentages.
- **Search by company name** if you don't have the profile URL.
- **Date cut-off** to scrape only reviews newer than a given date — ideal for daily or weekly monitoring.
- **Automatic IP rotation** when an exit IP gets challenged, up to 8 attempts per company.

***

### 🧠 Why This Actor Is Different

**1. It gets past the login wall — most scrapers don't.**
Kununu shows logged-out visitors only the **first 10 reviews** per company. Its API quietly accepts a `page` parameter from anonymous callers, echoes it back, and then returns page 1 again — HTTP 200, no error, no warning. A naive scraper looks like it works and silently returns the same 10 reviews forever. This Actor detects that condition, warns you in the log, and unlocks the full archive when you supply credentials.

**2. It sorts correctly.**
Kununu's default review order is *not* chronological — it descends within a page but jumps between them (page 100 can land in 2016 while page 150 lands in 2025). Any scraper relying on the default order will return an arbitrary slice and break date filtering. This Actor forces true newest-first ordering on every request.

**3. It clears the bot wall properly.**
Kununu is protected by AWS WAF on CloudFront. The Actor launches a hardened Firefox (Camoufox), earns the clearance token, then replays it from a fingerprint-matched HTTP client for the rest of the run — fast scraping with browser-grade trust. No CAPTCHA-solving service required or used.

**4. Salaries come from the right place.**
Kununu's salary API endpoint returns an empty array no matter what you send it. The real data is only in the server-rendered salary page. This Actor reads the correct source, so salary ranges actually come back populated.

***

### ⚙️ Input Configuration

#### Quick start

```json
{
  "startUrls": [{ "url": "https://www.kununu.com/de/audi" }],
  "maxReviewsPerCompany": 200,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"],
    "apifyProxyCountry": "DE"
  }
}
```

#### All input fields

| Field | Type | Default | Description |
|---|---|---|---|
| `startUrls` | array | — | Kununu profile URLs. **Any tab works** (`/kommentare`, `/gehalt`, `/jobs`) — it's reduced to the company automatically. `/de/`, `/at/`, `/ch/` all supported. |
| `searchQueries` | array | `[]` | Company names to look up when you don't have the URL. |
| `resultsPerQuery` | integer | `3` | How many matching profiles to keep per search term. |
| `scrapeReviews` | boolean | `true` | Collect employer reviews. |
| `reviewTypes` | array | `["employees"]` | `employees` (staff reviews) and/or `candidates` (application experiences). |
| `scrapeSalaries` | boolean | `true` | Collect per-job-title salary ranges. |
| `scrapeJobs` | boolean | `true` | Collect job listings. |
| `maxReviewsPerCompany` | integer | `0` | Cap reviews per company. `0` = no limit. |
| `maxSalariesPerCompany` | integer | `0` | Cap salary ranges. `0` = no limit. |
| `maxJobsPerCompany` | integer | `0` | Cap job listings. `0` = no limit. |
| `targetDate` | string | — | `YYYY-MM-DD`. Stop once reviews older than this date are reached. |
| `proxyConfiguration` | object | Residential DE | Proxy settings. Residential strongly recommended. |

> Kununu credentials are **not** run inputs. They are set once as environment variables on the Actor — see below.

#### 🔑 Credentials (environment variables)

**Without a kununu account you will get only the first 10 reviews per company.** This is kununu's restriction, not a limitation of this Actor. Salaries and jobs work fine without an account.

Credentials are set **once** on the Actor, not per run. In Apify Console go to your Actor → **Settings → Environment variables**, add them, and tick **Secret**.

| Variable | Description |
|---|---|
| `KUNUNU_EMAIL` | Kununu account email — **recommended** |
| `KUNUNU_PASSWORD` | Password for that account |
| `KUNUNU_ACCESS_TOKEN` | Alternative: the full `kununu_access_token_v1` cookie value from a logged-in browser |

**Which one should you use?**

- **`KUNUNU_EMAIL` + `KUNUNU_PASSWORD` — recommended.** The Actor logs in fresh at the start of every run and mints its own session, so nothing ever expires and nothing needs rotating. This is the only option that works unattended on a schedule.
- Kununu's default sign-in emails you a **one-time code**, and accounts created that way have no password to automate with. If yours is one of them, set a password in your kununu account settings and use the option above.
- Otherwise use `KUNUNU_ACCESS_TOKEN`. The JWT inside that cookie expires after about **3 hours**, regardless of the long expiry date your browser shows for the cookie itself, so it suits one-off and supervised runs.

**When the token expires, the run does not fail.** The Actor detects it before scraping, says so in the log, and continues without an account — you still get salaries, jobs and the first 10 reviews per company. Nothing is silently wrong.

> ⚠️ **Copy the right cookie.** It must be the full `kununu_access_token_v1` value, which contains an `access_token` JWT. A device or tracking id (a short base64 blob like `{"id":"…","created":…}`) will **not** work — kununu accepts it silently and returns page 1 forever. The Actor validates this on startup and stops with a clear message rather than quietly scraping 10 reviews.

To grab it: sign in to kununu, open DevTools → **Application → Cookies → www.kununu.com**, and copy the entire value of `kununu_access_token_v1`.

A free kununu account is enough. Marked as secret, these values are encrypted, hidden in the UI, and never written to the dataset, the logs, or the run's input record.

#### Tips for best results

- **Set the run timeout to at least 900 seconds.** Clearing the bot wall takes roughly 60 seconds per company.
- **Use residential proxies, country `DE`.** Datacenter IPs get challenged far more often.
- **Allocate at least 4 GB of memory** — the Actor runs a real browser to clear the wall.
- **Use `targetDate` for recurring runs** instead of re-scraping the full archive every time.
- **Start with one company and a small `maxReviewsPerCompany`** to confirm your credentials work before launching a large batch.

***

### 📤 Output Format

One dataset record per company. Reviews, salaries and jobs are nested arrays.

#### Sample output (abridged)

```json
{
  "uuid": "4f61a38b-d9a1-4fcf-8cfb-17faa4e27e66",
  "name": "AUDI AG",
  "slug": "audi",
  "countryCode": "de",
  "url": "https://www.kununu.com/de/audi",
  "website": "https://www.audi.com/de/careers/",
  "score": 4,
  "industryAverageScore": 3.5,
  "recommendationRate": 80,
  "totalReviews": 2569,
  "totalEmployeeReviews": 2418,
  "totalCandidateReviews": 151,
  "totalSalaryEntries": 1464,
  "isVerified": true,
  "isTopCompany": true,
  "topCompanyYears": [2026, 2025, 2024, 2023, 2022],
  "firstReviewYear": 2008,
  "headquarters": { "city": "Ingolstadt", "state": "Bayern", "countryCode": "de" },
  "totalLocations": 29,
  "employeeCount": "55.000",
  "benefits": [
    { "id": "cantine", "count": 1768, "percentage": 73 },
    { "id": "pensionPlan", "count": 1655, "percentage": 68 }
  ],
  "reviews": [
    {
      "id": "0359dc2e-6a49-495c-865c-94ce1b8957a5",
      "url": "https://www.kununu.com/de/audi/bewertung/0359dc2e-...",
      "title": "Top für Praktikanten im technischen Bereich",
      "score": 4.8,
      "recommended": true,
      "createdAt": "2026-09-19T00:00:00+00:00",
      "position": "intern",
      "department": "research",
      "employmentStatus": "former",
      "city": "Neckarsulm",
      "state": "Baden-Württemberg",
      "ratings": [
        { "factor": "atmosphere", "score": 5, "text": "Ich wurde gut aufgenommen…" },
        { "factor": "salary", "score": 4, "text": null }
      ],
      "texts": [
        { "kind": "positive", "text": "Gute Betreuung…" },
        { "kind": "negative", "text": "…" }
      ],
      "employerResponses": [
        { "text": "Vielen Dank für Ihre Bewertung…", "createdAt": "2026-09-21T00:00:00+00:00", "authorName": "Audi Karriereberatung" }
      ],
      "helpfulCount": 0,
      "agreeCount": 0
    }
  ],
  "salaries": [
    {
      "jobTitle": "Ingenieur:in",
      "jobTitleSlug": "ingenieur-in",
      "currency": "EUR",
      "min": 49100,
      "max": 124500,
      "median": 93500,
      "average": 92600,
      "entries": 80
    }
  ],
  "jobs": [
    {
      "id": "e618754e-ecbb-4050-93f0-7afde8043a3b",
      "title": "Senior Consultant Digitalisierung für die Prozessindustrie (all genders)",
      "url": "https://www.kununu.com/job-postings/de/e618754e-...",
      "city": "Neumünster",
      "region": "Schleswig-Holstein",
      "employmentTypes": ["JOB_EMPLOYMENT_FULLTIME"],
      "postedAt": "2026-09-22",
      "companyName": "adesso SE",
      "companySlug": "adesso",
      "jobTitleSalaryAverage": 65700
    }
  ]
}
```

#### Field reference

**Company level**

| Field | Description |
|---|---|
| `name`, `slug`, `url`, `website`, `logo` | Company identity |
| `score` | Overall kununu rating (1–5) |
| `industryAverageScore` | Industry benchmark, for direct comparison |
| `recommendationRate` | % of reviewers who recommend the employer |
| `totalReviews` / `totalEmployeeReviews` / `totalCandidateReviews` | Review counts **on kununu**, not the number scraped |
| `totalSalaryEntries` | Salary submissions behind the ranges |
| `isTopCompany`, `topCompanyYears` | Kununu "Top Company" award history |
| `firstReviewYear` | How far the archive goes back |
| `headquarters`, `totalLocations`, `employeeCount` | Company footprint |
| `benefits` | Perks with submission count and % of reviewers reporting them |
| `companyOverview` | The employer's own profile description |

**Review level** — `id`, `url`, `title`, `score`, `recommended`, `createdAt`, `updatedAt`, `position`, `department`, `employmentStatus` (`current`/`former`), `employedUntil`, `city`, `state`, `helpfulCount`, `agreeCount`, plus:

- `ratings[]` — `{ factor, score, text }` across the 13 rated factors (`atmosphere`, `image`, `workLife`, `career`, `salary`, `environment`, `teamwork`, `oldColleagues`, `leadership`, `workConditions`, `communication`, `equality`, `tasks`). Apprenticeship reviews use `apprenticeship*` factor names.
- `texts[]` — `{ kind, text }` where `kind` is `positive`, `negative` or `suggestion`.
- `employerResponses[]` — official replies with text, date and author.

**Salary level** — `jobTitle`, `jobTitleSlug`, `currency` (EUR), `min`, `max`, `median`, `average` (gross annual), `entries`.

**Job level** — `id`, `title`, `url`, `city`, `region`, `employmentTypes`, `postedAt`, `companyName`, `companySlug`, and kununu's benchmark `jobTitleSalaryAverage` / `Min` / `Max` for that role.

> **Note on jobs:** kununu's jobs tab pads itself with recommended listings from *other* companies. Every job carries its own `companyName` and `companySlug`, so filter on those if you only want the profile's own postings. An empty `jobs` array means the company genuinely has none listed.

Export as **JSON, CSV, Excel, XML or RSS** from the Apify console, or pull it via API.

***

### ▶️ How to Use

1. **Open the Actor** in Apify Console and click **Try for free**.
2. **Add a company.** Paste a kununu profile URL into *Company profile URLs* — for example `https://www.kununu.com/de/sap`. Or type a name into *Company names to search*.
3. **Set your kununu login once** in *Settings → Environment variables* (`KUNUNU_EMAIL`, `KUNUNU_PASSWORD`, both marked secret) if you want more than 10 reviews per company. Skip this if you only need salaries and jobs.
4. **Set your limits.** Leave everything at `0` for the full archive, or set *Max reviews per company* to keep the first run small.
5. **Set proxy** to Apify Residential, country Germany.
6. **Raise the run timeout** to 900 seconds or more, and memory to 4 GB.
7. **Click Start.** Watch the log — it reports each review page as it's collected.
8. **Download your data** from the *Storage → Dataset* tab in JSON, CSV or Excel.

#### Common workflows

**Scrape one company completely**

```json
{ "startUrls": [{ "url": "https://www.kununu.com/de/sap" }] }
```

**Weekly monitoring — only what's new**

```json
{ "startUrls": [{ "url": "https://www.kununu.com/de/sap" }],
  "targetDate": "2026-09-01", "scrapeSalaries": false, "scrapeJobs": false }
```

Schedule this daily or weekly in Apify and you get a clean incremental feed.

**Compare competitors**

```json
{ "searchQueries": ["Siemens", "Bosch", "Continental"], "resultsPerQuery": 1,
  "maxReviewsPerCompany": 300 }
```

**Salary benchmarking only — no account needed**

```json
{ "startUrls": [{ "url": "https://www.kununu.com/de/audi" }],
  "scrapeReviews": false, "scrapeJobs": false }
```

***

### 📈 Use Cases

**1. Employer brand benchmarking.** Pull your company and five competitors, then compare `score` against `industryAverageScore`, `recommendationRate`, and the 13 rated factors. You'll see exactly which factor drags your rating down — usually `salary`, `leadership` or `communication`.

**2. Salary benchmarking across DACH.** Extract per-job-title ranges with median and average in EUR, weighted by submission count. Useful for compensation reviews and offer calibration without buying a commercial dataset.

**3. Candidate-experience auditing.** Scrape `reviewTypes: ["candidates"]` to read what applicants say about your interview process — response times, interviewer behaviour, ghosting — and fix the leaks in your funnel.

**4. Reputation monitoring and alerting.** Run daily with `targetDate` set to yesterday. Push new negative reviews (`score <= 2` or `recommended: false`) into Slack so HR can respond within hours instead of weeks.

**5. Sales intelligence and lead generation.** Companies with active job listings are hiring and spending. Combine `jobs` with poor `score` or falling `recommendationRate` to find prospects for HR tech, recruiting services, employer branding or culture consulting.

**6. Academic and market research.** Longitudinal sentiment analysis over review archives reaching back to 2008, segmented by `position`, `department`, `city` and `employmentStatus`.

***

### 🛠️ Advanced Tips

**Performance**

- The bot wall is cleared **once per company**, taking ~60 seconds. Scraping itself is fast — roughly 1 second per review page (10 reviews). A 2,400-review company takes about 5 minutes of pagination plus the one-time wall clearance.
- Turn off what you don't need. `scrapeSalaries: false` and `scrapeJobs: false` noticeably shorten review-only runs.

**Proxies**

- Residential proxies in Germany give the best clearance rate. Datacenter IPs are challenged much more aggressively.
- If an IP gets challenged mid-run, the Actor rotates to a fresh proxy session automatically and retries — up to 8 IPs per company.

**Scaling**

- Split large company lists across several scheduled runs rather than one enormous run. Each company needs its own wall clearance, so 100 companies means ~100 minutes of clearance alone.
- Access tokens expire after ~3 hours. For any long or scheduled job, use `KUNUNU_EMAIL` + `KUNUNU_PASSWORD` so the Actor re-authenticates each run.
- Use the Apify API or a webhook to stream results into your own storage as they're produced.

***

### ❓ FAQ & Troubleshooting

**I only get 10 reviews per company. Why?**
You're running without credentials. Kununu limits logged-out visitors to the first 10 reviews of each company. Set the `KUNUNU_EMAIL` and `KUNUNU_PASSWORD` environment variables on the Actor. The run log warns you when this happens.

**Do I need a paid kununu account?**
No. A free account is enough to unlock full review pagination.

**Is my kununu password safe?**
Credentials live in **secret environment variables**, not in run inputs — encrypted at rest, hidden in the UI, and never written to the dataset, the log, or any run's stored input. If you'd rather not supply a password, use `KUNUNU_ACCESS_TOKEN` instead.

**My access token stopped working mid-run.**
The JWT inside the cookie expires after about 3 hours — the long expiry date your browser shows for the cookie is *not* the token's lifetime. The Actor warns you at startup when under 30 minutes remain, and logs a clear message if the fence comes up mid-scrape. Use `KUNUNU_EMAIL` + `KUNUNU_PASSWORD` if your account has a password.

**Kununu only emails me a login code — I have no password. What now?**
Kununu's default sign-in is a one-time emailed code, and those accounts have no password to automate. Either set a password in your kununu account settings and use `KUNUNU_EMAIL` + `KUNUNU_PASSWORD`, or paste a fresh `KUNUNU_ACCESS_TOKEN` before each run. There is no way to refresh or extend a token — kununu exposes no refresh endpoint.

**The Actor exits immediately saying my token "does not contain a JWT".**
You copied the wrong cookie. It must be `kununu_access_token_v1`, whose value contains an `access_token` with three dot-separated parts. Device ids and tracking cookies look similar but carry no credentials.

**The run failed with "AWS WAF challenged…" on every attempt.**
All 8 proxy IPs were blocked. Switch to **residential** proxies, set the country to `DE`, and make sure the run timeout is at least 900 seconds. Datacenter proxies frequently fail here.

**The `jobs` array is empty.**
That's real data, not an error. Many profiles have no active listings. Check `totalReviews` and `salaries` — if those are populated, the scrape worked correctly.

**Why are the reviews in German?**
Kununu is a DACH platform and reviews are written in German (occasionally English). The Actor returns the original text unmodified — translate downstream if you need to.

**Can I scrape Austrian or Swiss companies?**
Yes. `/at/` and `/ch/` profile URLs work exactly the same way. Note that kununu's tab names stay German across all three countries (`/gehalt`, `/kommentare`, `/jobs`).

**Can I get apprenticeship reviews separately?**
Kununu has no separate apprenticeship stream — they're employee reviews with `position: "apprentice"`. Filter the `reviews` array on that field.

**How far back does the data go?**
To the company's first review. Many large profiles reach back to 2008 — check `firstReviewYear`.

**The run is slow.**
That's the bot wall, ~60 seconds per company, and it's unavoidable. Reduce the number of companies per run, or disable the sections you don't need.

**Can I run this on a schedule?**
Yes. Use Apify Schedules with `targetDate` set to your last run date for efficient incremental scraping.

***

### ⚖️ Legal & Fair Use

This Actor collects **publicly available** employer review data for research, benchmarking and analysis. You are responsible for how you use the data, including compliance with GDPR and kununu's terms of service. Review text may contain personal opinions — treat it accordingly, avoid attempting to identify individual reviewers, and don't republish content wholesale. Use reasonable limits rather than scraping aggressively.

***

### 📞 Support

Questions, bug reports or feature requests are welcome.

- **Email:** <me@ahmedhrid.com>
- **Issues:** open an issue on the Actor's Apify page

When reporting a problem, please include the **run ID**, your **input configuration** (with credentials removed), and the relevant part of the **run log**. That makes it much faster to diagnose.

***

#### Keywords

kununu scraper, kununu API, employer reviews scraper, Apify actor, web scraping, company reviews Germany, DACH employer data, salary data scraping, Gehalt scraper, employer branding data, HR analytics, job listings scraper, competitor benchmarking, Arbeitgeberbewertungen, employee reviews Austria, employee reviews Switzerland, leads scraping, recruitment data.

# Actor input Schema

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

Kununu company profile URLs, e.g. https://www.kununu.com/de/audi. Any tab of a profile works (/kommentare, /gehalt, /jobs) — it is reduced to the company. Austrian (/at/) and Swiss (/ch/) profiles are supported.

## `searchQueries` (type: `array`):

Company names to look up on kununu when you do not have the profile URL. Each match is scraped like a startUrl.

## `resultsPerQuery` (type: `integer`):

How many matching profiles to keep for each entry in 'Company names to search'.

## `scrapeReviews` (type: `boolean`):

Collect employer reviews. Without kununu credentials in the actor's environment variables (KUNUNU\_EMAIL + KUNUNU\_PASSWORD) only the first 10 reviews per company are reachable.

## `reviewTypes` (type: `array`):

Which review streams to collect. 'employees' are current/former staff reviews; 'candidates' are job-application experiences.

## `scrapeSalaries` (type: `boolean`):

Collect the per-job-title salary ranges (min, max, median, average) from the company's salary tab.

## `scrapeJobs` (type: `boolean`):

Collect job listings from the company's jobs tab.

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

Stop after this many reviews per company. 0 means no limit.

## `maxSalariesPerCompany` (type: `integer`):

Stop after this many salary ranges per company. 0 means no limit.

## `maxJobsPerCompany` (type: `integer`):

Stop after this many job listings per company. 0 means no limit.

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

ISO date (YYYY-MM-DD). Reviews are fetched newest-first, so collection stops once a review older than this date is reached.

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

Residential proxies are strongly recommended — the actor rotates the exit IP whenever AWS WAF challenges a session.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.kununu.com/de/audi"
    }
  ],
  "searchQueries": [],
  "resultsPerQuery": 3,
  "scrapeReviews": true,
  "reviewTypes": [
    "employees"
  ],
  "scrapeSalaries": true,
  "scrapeJobs": true,
  "maxReviewsPerCompany": 0,
  "maxSalariesPerCompany": 0,
  "maxJobsPerCompany": 0,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "DE"
  }
}
```

# Actor output Schema

## `companies` (type: `string`):

Dataset with one record per kununu profile: company name, slug, country, website, kununu score, industry average, recommendation rate, review and salary counts, benefits, headquarters, employee count, and the arrays of review, salary and job objects.

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "startUrls": [
        {
            "url": "https://www.kununu.com/de/audi"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("reviewly/kunnu-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "startUrls": [{ "url": "https://www.kununu.com/de/audi" }] }

# Run the Actor and wait for it to finish
run = client.actor("reviewly/kunnu-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 '{
  "startUrls": [
    {
      "url": "https://www.kununu.com/de/audi"
    }
  ]
}' |
apify call reviewly/kunnu-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,reviewly/kunnu-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/4z8uh1ajO41kFWxsy/builds/bDEcLmoe3gWWYcZxl/openapi.json