# Kununu Reviews Scraper (`automation-lab/kununu-reviews-scraper`) Actor

🧾 Export public Kununu employee reviews with scores, written feedback, rating factors, recommendation signals, employer replies, and company context. Built for employer-brand monitoring, recruiting intelligence, HR analytics, and competitive research.

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

## Pricing

Pay per event + usage

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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 Reviews Scraper

Collect public Kununu employee reviews, employer ratings, recommendation signals, rating dimensions, and company replies from Germany, Austria, and Switzerland.

Turn pages of workplace feedback into clean rows for employer-brand monitoring, recruiting intelligence, HR research, and competitive analysis.

- 🧾 One dataset row per employee review
- ⭐ Overall and dimension-level ratings
- 💬 Written feedback and employer responses
- 📊 Company score, review count, and recommendation rate
- 🇩🇪 Germany, 🇦🇹 Austria, and 🇨🇭 Switzerland
- 🔁 Multiple companies and automatic pagination

### What does Kununu Reviews Scraper do?

Kununu Reviews Scraper accepts one or more public Kununu company URLs.

It visits each employee-review page, follows pagination, removes duplicates, and saves structured review records to an Apify dataset.

Each row combines the individual review with useful company context.

That means analysts can compare review text and scores without repeatedly joining a separate company table.

The Actor uses Kununu's public structured page data.

No Kununu login is required.

### Who is it for?

#### Employer-brand teams

Track what current and former employees say about your organization.

Monitor rating changes, recommendation signals, and recurring workplace themes.

#### Recruiters and talent teams

Research candidate perception before starting a hiring campaign.

Compare employer sentiment across target companies and locations.

#### HR analytics companies

Feed dated review records into dashboards, sentiment models, and benchmark reports.

#### Reputation agencies

Monitor several client and competitor profiles on a repeat schedule.

#### Labor and workplace researchers

Build source-linked datasets for longitudinal studies of employee experience.

### Why use this Kununu scraper?

Manual review collection is slow and difficult to repeat consistently.

A structured scraper makes the workflow reproducible.

- ⚡ Export many reviews in one run
- 🔗 Keep source URLs and stable review IDs
- 🧩 Preserve all available Kununu rating dimensions
- 🕒 Capture created, updated, and scraped timestamps
- 🏢 Include public company aggregates on every row
- ♻️ Prevent duplicate output within a run
- 📦 Export as JSON, CSV, Excel, XML, RSS, or JSONL through Apify

### What Kununu data can I extract?

| Field group | Example fields | Use |
|---|---|---|
| Review identity | `reviewId`, `reviewUrl`, `sourceUrl` | Auditing and deduplication |
| Company | `companyName`, `companySlug`, `companyProfileUrl` | Grouping and comparison |
| Company metrics | `companyScore`, `companyReviewCount`, `companyRecommendationRate` | Employer benchmarking |
| Review content | `title`, `body`, `createdAt`, `updatedAt` | Text and trend analysis |
| Review score | `score`, `roundedScore`, `recommended` | Quantitative analysis |
| Reviewer context | `formerEmployee`, `position`, `department`, `reviewerLocation` | Segmentation |
| Rating factors | `ratings`, `dimensionScores`, `dimensionComments` | Workplace-driver analysis |
| Company replies | `employerResponses` | Response monitoring |
| Reactions | `helpfulCount`, `agreeCount` | Engagement signals |
| Collection metadata | `pageNumber`, `scrapedAt` | Pipeline observability |

Kununu can vary the factors shown for different review types and dates.

The Actor therefore preserves dimension IDs dynamically instead of discarding unrecognized factors.

### How to scrape Kununu employee reviews

1. Open the Actor input page.
2. Paste a public Kununu company or `/kommentare` URL.
3. Set the maximum number of reviews.
4. Keep the residential proxy setting enabled.
5. Click **Start**.
6. Open the **Dataset** tab when the run finishes.
7. Export or integrate the records in your preferred format.

A small first run is recommended before a large monitoring job.

### Input settings

#### Kununu company URLs

Use public company URLs such as:

```text
https://www.kununu.com/de/pwc/kommentare
https://www.kununu.com/at/example-company
https://www.kununu.com/ch/example-company/kommentare
````

Both profile and employee-review URLs are normalized to the review feed.

#### Maximum reviews

`maxReviews` limits unique records across all supplied companies.

The default is intentionally small for an inexpensive first run.

#### Maximum pages per company

`maxPagesPerCompany` is a pagination safety limit.

Kununu normally returns ten employee reviews per page.

#### Proxy configuration

Residential proxy access is enabled because Kununu blocks ordinary datacenter requests.

Keep the `RESIDENTIAL` group selected for reliable extraction.

### Example input

```json
{
  "startUrls": [
    { "url": "https://www.kununu.com/de/pwc/kommentare" },
    { "url": "https://www.kununu.com/de/siemens/kommentare" }
  ],
  "maxReviews": 30,
  "maxPagesPerCompany": 3,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
```

The total output stops at 30 unique reviews even when more are available.

### Example output

```json
{
  "reviewId": "8db5a45a-c01c-4d21-9ad0-2fc43c1b2610",
  "reviewUrl": "https://www.kununu.com/de/pwc/kommentare/8db5a45a-c01c-4d21-9ad0-2fc43c1b2610",
  "companyName": "PwC Deutschland",
  "companySlug": "pwc",
  "companyScore": 3.6,
  "companyReviewCount": 2821,
  "companyRecommendationRate": 78,
  "title": "Werkstudent im Public sector",
  "body": "Flexibel und angenehm\n\nSpannende Aufgabenbereiche passend zum Studium",
  "score": 4.8,
  "createdAt": "2026-07-10T00:00:00+00:00",
  "recommended": true,
  "position": "student",
  "dimensionScores": {
    "atmosphere": 5,
    "tasks": 5,
    "workLife": 5
  },
  "helpfulCount": 0,
  "scrapedAt": "2026-07-15T00:00:00.000Z"
}
```

Fields remain typed and optional source values use `null`, empty arrays, or empty objects.

### How much does it cost to scrape Kununu reviews?

The Actor uses transparent pay-per-event pricing.

- **Start:** $0.005 per run
- **Review extracted:** tiered per saved review; BRONZE $0.0038364, with lower rates on higher Apify plans

Apify platform usage may also apply according to your plan.

The exact event prices are shown on the Actor pricing tab before a run starts.

Residential bandwidth is the main source-access cost, so avoid requesting pages you do not need.

Use `maxReviews` and `maxPagesPerCompany` to control spend.

### Employer reputation monitoring workflow

Create an Apify schedule with a stable list of company URLs.

Send finished datasets to a webhook, cloud storage, or a database.

Use `reviewId` as the upsert key.

Filter to records with a newer `createdAt` than the previous collection window.

Chart company score, recommendation rate, review score, and factor scores over time.

Alert the employer-brand team when low-score reviews or repeated themes appear.

### Competitor benchmarking workflow

Run the same input for your company and selected hiring competitors.

Group rows by `companySlug`.

Compare:

- Overall review-score distribution
- Recommendation rate
- Work-life and salary dimensions
- Review volume over time
- Employer response coverage
- Helpful and agree reactions

Always retain source URLs so analysts can verify context.

### Tips for reliable results

- ✅ Start with one company and 10–20 reviews.
- ✅ Use canonical public Kununu URLs.
- ✅ Keep residential proxy access enabled.
- ✅ Set a realistic page cap for scheduled runs.
- ✅ Deduplicate across runs with `reviewId`.
- ✅ Treat public ratings as observations, not verified employment facts.
- ✅ Review source pages before publishing conclusions about individuals or companies.

### Integrations

#### Google Sheets

Export a dataset as CSV or connect Apify through Make or Zapier.

Use one row per review for filters and pivot tables.

#### Business intelligence tools

Load JSON or CSV into Power BI, Tableau, Looker Studio, or Metabase.

Flatten `dimensionScores` when your warehouse requires fixed columns.

#### Webhooks

Configure an Actor run-finished webhook to start a sentiment or alerting pipeline.

#### Cloud storage

Use Apify integrations to deliver datasets to Amazon S3, Google Drive, or another supported destination.

#### AI analysis

Send the review title, body, and dimension comments to a classifier or summarizer.

Keep the source URL and review ID alongside generated analysis.

### API usage in JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/kununu-reviews-scraper').call({
  startUrls: [{ url: 'https://www.kununu.com/de/pwc/kommentare' }],
  maxReviews: 20,
  maxPagesPerCompany: 2
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Run with the Apify API in Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("automation-lab/kununu-reviews-scraper").call(run_input={
    "startUrls": [{"url": "https://www.kununu.com/de/pwc/kommentare"}],
    "maxReviews": 20,
    "maxPagesPerCompany": 2,
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

### Run with cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~kununu-reviews-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "startUrls": [{"url":"https://www.kununu.com/de/pwc/kommentare"}],
    "maxReviews": 20,
    "maxPagesPerCompany": 2
  }'
```

Fetch records from the run's `defaultDatasetId` after it succeeds.

### Use Kununu Reviews Scraper with MCP

Apify's MCP server lets AI assistants call the Actor as a tool.

For Claude Code, connect the server URL with the Actor tool selected:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/kununu-reviews-scraper"
```

For **Claude Desktop**, **Cursor**, or **VS Code**, add this `mcpServers` JSON configuration:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/kununu-reviews-scraper"
    }
  }
}
```

In Claude Desktop, open Settings → Developer and edit the MCP configuration. In Cursor, open Settings → MCP. In VS Code, add the same server in your MCP extension or workspace configuration.

Example prompts to try:

- “Collect the newest 20 public employee reviews for this Kununu company.”
- “Compare recommendation rates and work-life scores for these three employers.”
- “Summarize recurring negative themes and include source URLs.”
- “Find reviews with employer responses and group them by score.”

### Scheduling and repeat monitoring

Use Apify schedules to run daily, weekly, or monthly.

For incremental downstream processing:

1. Keep a table keyed by `reviewId`.
2. Upsert each new dataset.
3. Store `updatedAt` and `scrapedAt` separately.
4. Trigger notifications only for newly observed IDs or changed records.
5. Retain historical company aggregates for trend charts.

The Actor deduplicates within one run; your destination should deduplicate across runs.

### Data quality and source behavior

Kununu can change page structure, public counts, or review availability.

A review may be updated, moderated, or removed after collection.

Company aggregates and review-feed metrics can cover different time windows.

Some older reviews do not expose every rating factor or reviewer-context field.

The Actor preserves available data rather than inventing missing values.

### Limitations

- Public employee reviews are supported; applicant interview reviews and salary records are not part of this focused Actor.
- A Kununu login does not unlock private data and is not used.
- Residential proxy access is required for the proven route.
- Very large companies require multiple pages and more bandwidth.
- Source-side moderation can change historical availability.
- Dynamic factor IDs may differ across locales or review versions.
- The Actor does not perform sentiment scoring; use the extracted text in your preferred model.

### Legality

This Actor collects information displayed on public Kununu pages.

Web scraping laws and contractual obligations depend on jurisdiction, purpose, and data handling.

You are responsible for complying with applicable law, Kununu's terms, robots guidance where applicable, and privacy requirements.

Use proportionate limits.

Do not use the data to harass reviewers, infer protected traits, or make automated decisions about identifiable people.

For legal-sensitive use cases, consult qualified counsel.

### Troubleshooting

#### The run says a URL is invalid

Use a public URL with this shape:

```text
https://www.kununu.com/de/company-slug/kommentare
```

Only `de`, `at`, and `ch` company paths are accepted.

#### The run receives HTTP 403 or 405

Confirm that Apify Proxy is enabled and the `RESIDENTIAL` group remains selected.

The Actor rotates sessions automatically on blocked responses.

#### Fewer reviews were returned than requested

The profile may have fewer public employee reviews, the page cap may be reached, or duplicate/removed records may reduce output.

Increase `maxPagesPerCompany` only when more pages exist.

#### Some factor fields are empty

Kununu reviews vary by age and review type.

Inspect `ratings`, `dimensionScores`, and `dimensionComments`; missing source values are not fabricated.

### FAQ

#### Does the Actor need my Kununu account?

No. It extracts anonymously accessible public company-review pages.

#### Can I scrape several employers in one run?

Yes. Add multiple URLs to `startUrls` and set a global `maxReviews` limit.

#### Does it extract pros, cons, and suggestions?

It preserves all written dimension comments exposed by Kununu, keyed by their source factor IDs.

This is more resilient than forcing changing source dimensions into a few fixed labels.

#### Are employer replies included?

Yes. Public reply text, author label, response ID, and timestamp are included when available.

#### Can I export to Excel?

Yes. Open the dataset export menu and select Excel, CSV, JSON, XML, RSS, or JSONL.

#### Can I monitor only new reviews?

Schedule repeated runs and deduplicate in your destination by `reviewId`.

#### Why is a residential proxy used?

Kununu returned complete public HTML through a German residential route while datacenter traffic was blocked.

#### Is the output translated?

No. Review text remains in its source language so analysis does not lose meaning.

### Related scrapers

Combine this Actor with other Automation Lab tools when your workflow needs wider reputation or market context:

- [Google Maps Reviews Scraper](https://apify.com/automation-lab/google-maps-reviews-scraper) for location-level customer feedback
- [Trustpilot Scraper](https://apify.com/automation-lab/trustpilot-scraper) for consumer reputation signals
- [Glassdoor Scraper](https://apify.com/automation-lab/glassdoor-scraper) for broader employer-research workflows

Use only the tools that match your source and compliance requirements.

### Support

If a valid public Kununu company URL produces unexpected output, open an issue on the Actor page.

Include:

- The affected public URL
- A small reproducible input
- The run ID
- The expected and actual behavior

Do not include private credentials or personal data in support messages.

# Actor input Schema

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

Company profile or employee-review URLs, for example https://www.kununu.com/de/pwc/kommentare. German, Austrian, and Swiss profiles are supported.

## `maxReviews` (type: `integer`):

Maximum number of unique employee reviews to save across all companies.

## `maxPagesPerCompany` (type: `integer`):

Safety limit for Kununu pagination. Each page normally contains 10 reviews.

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

Keep the Residential group enabled for reliable access to public Kununu pages.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.kununu.com/de/pwc/kommentare"
    }
  ],
  "maxReviews": 20,
  "maxPagesPerCompany": 2,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `overview` (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 = {
    "startUrls": [
        {
            "url": "https://www.kununu.com/de/pwc/kommentare"
        }
    ],
    "maxReviews": 20,
    "maxPagesPerCompany": 2,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/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 = {
    "startUrls": [{ "url": "https://www.kununu.com/de/pwc/kommentare" }],
    "maxReviews": 20,
    "maxPagesPerCompany": 2,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/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 '{
  "startUrls": [
    {
      "url": "https://www.kununu.com/de/pwc/kommentare"
    }
  ],
  "maxReviews": 20,
  "maxPagesPerCompany": 2,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call automation-lab/kununu-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Kununu Reviews Scraper",
        "description": "🧾 Export public Kununu employee reviews with scores, written feedback, rating factors, recommendation signals, employer replies, and company context. Built for employer-brand monitoring, recruiting intelligence, HR analytics, and competitive research.",
        "version": "0.1",
        "x-build-id": "SCCpWTCJb5rV74OQI"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~kununu-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-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/automation-lab~kununu-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-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/automation-lab~kununu-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-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": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "Kununu company URLs",
                        "type": "array",
                        "description": "Company profile or employee-review URLs, for example https://www.kununu.com/de/pwc/kommentare. German, Austrian, and Swiss profiles are supported.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxReviews": {
                        "title": "Maximum reviews",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of unique employee reviews to save across all companies.",
                        "default": 20
                    },
                    "maxPagesPerCompany": {
                        "title": "Maximum pages per company",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Safety limit for Kununu pagination. Each page normally contains 10 reviews.",
                        "default": 20
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Keep the Residential group enabled for reliable access to public Kununu pages.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```