# GoWork France Company & Reviews Scraper (`solidcode/gowork-fr-scraper`) Actor

\[💰 $1.6 / 1K] Extract company profiles and employee reviews from GoWork France (gowork.fr): name, address, website, firmographics (tax ID, capital, employees, founding date), ratings, and full reviews as separate rows. Search by company name or URL. For employer research and reputation monitoring.

- **URL**: https://apify.com/solidcode/gowork-fr-scraper.md
- **Developed by:** [SolidCode](https://apify.com/solidcode) (community)
- **Categories:** Automation, Developer tools, Jobs
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.20 / 1,000 companies

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## GoWork France Company & Reviews Scraper

Pull French employer profiles and their employee reviews from GoWork France (gowork.fr) at scale — company name, address, website, SIREN tax ID, employee band, business area, an overall star rating, a full 1–5★ rating histogram, and every review with its star rating, full text, reviewer, date, and employer replies. Companies and reviews come back as separate, joinable rows. Built for HR and talent teams, recruiters, and employer-brand analysts who need structured French employer-reputation data without collecting it company by company.

### Why This Scraper?

- **Two record types, one run** — every row carries a `recordType` of `company` or `review`, and each review links back to its employer by `companySlug` and `companyId`, so you can load a flat companies table and a flat reviews table and join them cleanly.
- **Firmographics on every company** — SIREN tax ID, postal address, business area, employee band, website, description, and company logo, pulled straight from the GoWork profile without a manual lookup.
- **Full 1–5★ rating histogram** — not just the average: `ratingDistribution` gives the exact count of 1, 2, 3, 4, and 5-star reviews per employer, plus the authoritative total review count, for real reputation breakdowns.
- **Complete review threads with employer replies** — each review carries the reviewer name, star rating, full text, and date, plus a nested `replies` array capturing the employer's and others' responses — the whole conversation, not just the opening complaint.
- **Search by company name OR paste a URL** — type "Carrefour" or "boulangerie Paris" and each term runs a live GoWork search, or paste exact company-profile and search-result URLs to target precisely the employers you want.
- **Per-company review cap you control** — set `maxReviewsPerCompany` to keep runs lean on the biggest employers (newest-first) or set it to `0` to pull every review on a profile.
- **Rated-only and since-date review filters** — flip `onlyRatedReviews` to drop text-only comments and question-and-answer threads, or set `reviewsStartDate` to collect only reviews published on or after a chosen day.
- **Unrated reviews stay honest** — a text-only or Q&A review comes back as `rating: null`, never a misleading zero, so your star distributions aren't skewed.
- **Company-only mode for cheap runs** — turn `includeReviews` off to pull just profiles and firmographics at the lower per-company rate when you don't need the review text.

### Use Cases

**Talent & HR Intelligence**
- Benchmark a French employer's overall rating against competitors in the same business area
- Break down reputation with the exact 1–5★ histogram, not just the headline average
- Track employee sentiment shifts by filtering reviews from a chosen start date
- Build a shortlist of the best-rated employers in a city or sector

**Employer-Brand & Reputation Monitoring**
- Monitor new reviews on your own company and respond via the captured reply threads
- Measure how often employers reply to reviews and how quickly
- Spot recurring themes in employee complaints and praise across review text
- Compare rated reviews against unrated Q&A threads to gauge engagement

**Recruitment Research**
- Screen prospective employers for candidates by rating and review volume
- Compare branch-level reputation for large chains fragmented across city profiles
- Assemble a data set of employer firmographics for a target region
- Track hiring-brand strength across an entire industry

**Sales & Lead Enrichment**
- Enrich a prospect list of French companies with SIREN tax IDs and business areas
- Segment target accounts by employee band and location
- Identify companies actively managing their employer reputation (frequent replies)
- Build account profiles combining firmographics, ratings, and review counts

**Market Research**
- Map employer reputation across a French industry or region
- Compare rating distributions between sectors or company sizes
- Quantify review volume and engagement as a signal of company scale
- Feed structured employer data into dashboards and BI tools

### Getting Started

#### Search by Company Name

The simplest run — search an employer and pull its profile plus reviews:

```json
{
    "searchQueries": ["Carrefour"],
    "maxCompanies": 5
}
````

#### A Specific Company by URL, With a Review Cap

Paste a GoWork profile URL and cap how many reviews you collect per company:

```json
{
    "startUrls": ["https://gowork.fr/randstad-france"],
    "maxReviewsPerCompany": 40
}
```

#### Companies Only — No Reviews

Pull firmographics and ratings at the lower per-company rate, with review text switched off:

```json
{
    "searchQueries": ["Decathlon", "Leroy Merlin"],
    "includeReviews": false,
    "maxCompanies": 25
}
```

#### Advanced — Rated, Recent Reviews Only

Search several employers and keep only star-rated reviews published since a chosen date:

```json
{
    "searchQueries": ["Renault", "Airbus"],
    "maxCompanies": 20,
    "includeReviews": true,
    "maxReviewsPerCompany": 100,
    "onlyRatedReviews": true,
    "reviewsStartDate": "2024-01-01"
}
```

### Input Reference

#### What to Scrape

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `startUrls` | string\[] | `[]` | GoWork France URLs — company profile pages, search-result pages, or listing pages. The most precise way to target exactly the companies you want. Leave blank to use search terms. |
| `searchQueries` | string\[] | `["Carrefour"]` | Free-text company searches, e.g. "Renault", "Carrefour", or "boulangerie Paris". Each term runs a GoWork France search and collects the matching companies — no manual URL lookup. |

#### Limits

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `maxCompanies` | integer | `100` | Cap on the total number of companies collected across all URLs and search terms. Set to `0` for no cap. |

#### Reviews

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `includeReviews` | boolean | `true` | Collect each company's employee reviews (rating, text, reviewer, date, and replies) as their own rows. Turn off for faster, cheaper runs that return only company profiles and firmographics. |
| `maxReviewsPerCompany` | integer | `0` | Cap on reviews captured per company, most recent first. `0` = all reviews, capped at a 2000-review safety ceiling per company. Ignored when reviews are off. |
| `onlyRatedReviews` | boolean | `false` | Keep only reviews that carry a 1–5 star rating. Turn on to exclude text-only comments and question-and-answer threads. Ignored when reviews are off. |
| `reviewsStartDate` | string | — | Only collect reviews published on or after this date, in `YYYY-MM-DD` format (e.g. `2024-01-15`). Leave blank to collect all reviews. Ignored when reviews are off. |

### Output

Every row carries a `recordType` field — `company` or `review` — so the two sides split and rejoin easily. Each review references its parent company by `companySlug` and `companyId`.

#### Company (`recordType: "company"`)

```json
{
    "recordType": "company",
    "companyName": "Randstad France",
    "slug": "randstad-france",
    "companyId": "12345",
    "companyUrl": "https://gowork.fr/randstad-france",
    "description": "Randstad est un acteur mondial du recrutement et des ressources humaines...",
    "website": "https://www.randstad.fr",
    "address": "276 avenue du Président Wilson, 93210, La Plaine Saint-Denis",
    "businessArea": "Recrutement et ressources humaines",
    "employeeCount": "1000+",
    "taxId": "433999356",
    "logoUrl": "https://gowork.fr/images/randstad-france.png",
    "overallRating": 3.4,
    "reviewCount": 48,
    "ratingDistribution": { "1": 16, "2": 3, "3": 1, "4": 1, "5": 7 },
    "language": "fr",
    "scrapedAt": "2026-07-04T14:30:00Z"
}
```

| Field | Type | Description |
|-------|------|-------------|
| `recordType` | string | Always `"company"` |
| `companyName` | string | Company name |
| `slug` | string | GoWork URL slug, e.g. `randstad-france` |
| `companyId` | string | GoWork company identifier |
| `companyUrl` | string | GoWork company profile URL |
| `description` | string | Company description text |
| `website` | string | Company website URL |
| `address` | string | Postal address |
| `businessArea` | string | Industry / business area |
| `employeeCount` | string | Employee count band |
| `taxId` | string | SIREN tax identifier |
| `logoUrl` | string | Company logo image URL |
| `overallRating` | number | Overall star rating (1–5) |
| `reviewCount` | number | Total number of reviews on the profile |
| `ratingDistribution` | object | Count of reviews per star, e.g. `{ "1": 16, "5": 7 }` |
| `language` | string | Profile language (`fr`) |
| `scrapedAt` | string | ISO timestamp of data extraction |

#### Review (`recordType: "review"`)

Emitted when `includeReviews` is on, up to `maxReviewsPerCompany` per company.

```json
{
    "recordType": "review",
    "companyName": "Randstad France",
    "companyUrl": "https://gowork.fr/randstad-france",
    "companySlug": "randstad-france",
    "companyId": "12345",
    "reviewId": "987654",
    "reviewerName": "Marie L.",
    "authorType": "employee",
    "rating": 4,
    "content": "Bonne ambiance d'équipe et management à l'écoute. Les horaires peuvent être longs en haute saison.",
    "date": "12-03-2024 09:15",
    "language": "fr",
    "replies": [
        {
            "replyId": "987655",
            "author": "Randstad France",
            "authorType": "company",
            "content": "Merci pour votre retour, nous en tenons compte.",
            "date": "14-03-2024 10:02"
        }
    ],
    "scrapedAt": "2026-07-04T14:30:05Z"
}
```

| Field | Type | Description |
|-------|------|-------------|
| `recordType` | string | Always `"review"` |
| `companyName` | string | Parent company's name |
| `companyUrl` | string | Parent company's GoWork URL |
| `companySlug` | string | Parent company's slug — join key back to the company row |
| `companyId` | string | Parent company's identifier |
| `reviewId` | string | Unique review identifier |
| `reviewerName` | string | Reviewer's name or label |
| `authorType` | string | Reviewer type (e.g. employee, candidate) |
| `rating` | number | Star rating, 1–5 (`null` when the review carries no star) |
| `content` | string | Full review text |
| `date` | string | Publish date and time (day-first, `DD-MM-YYYY HH:MM`) |
| `language` | string | Review language (`fr`) |
| `replies` | object\[] | Replies to the review — each with `replyId`, `author`, `authorType`, `content`, and `date` |
| `scrapedAt` | string | ISO timestamp of data extraction |

### Tips for Best Results

- **Big brands are split into city-level profiles.** GoWork fragments large employers (Carrefour, Decathlon) across many local-branch pages. Search the brand name and page through the results to gather every branch, or paste specific branch URLs when you want just one location.
- **Start small to test.** Set `maxCompanies` to 5 on your first run to confirm the fields match your needs, then scale up.
- **Turn reviews off when you only need firmographics.** `includeReviews: false` skips all review fetching for a much faster, cheaper run when you just want profiles, ratings, and SIREN tax IDs.
- **Cap reviews on high-volume employers.** Some large French employers carry hundreds of reviews. Set `maxReviewsPerCompany` (e.g. 50–100) to keep runs lean and predictable, or `0` to pull the full set up to a 2,000-review safety ceiling per company.
- **Use `onlyRatedReviews` for cleaner sentiment analysis.** It drops text-only comments and Q\&A threads so your data set is limited to reviews with a real 1–5 star score.
- **Join companies to reviews on `companySlug`.** Both record types carry `companySlug` and `companyId`, so you can rebuild the one-company-to-many-reviews relationship in any spreadsheet or database.
- **Read the histogram, not just the average.** `ratingDistribution` reveals polarized employers — a 3.4 average made of mostly 1s and 5s tells a very different story than a flat spread of 3s.

### Pricing

**From $2.20 per 1,000 companies + $0.55 per 1,000 reviews collected.** You're charged per company profile plus per review collected — reviews are billed at a lower rate. No compute or time-based charges — you pay only for the records you receive.

Companies and reviews each have their own discount ladder. Apify's loyalty tiers (Bronze, Silver, Gold) apply automatically on your account — the more you run, the less you pay.

**Company records (per 1,000):**

| Volume | No discount | Bronze | Silver | Gold |
|--------|-------------|--------|--------|------|
| 1,000 companies | $2.60 | $2.50 | $2.35 | $2.20 |

**Review records (per 1,000):**

| Volume | No discount | Bronze | Silver | Gold |
|--------|-------------|--------|--------|------|
| 1,000 reviews | $0.65 | $0.61 | $0.58 | $0.55 |

Here's what realistic parent/child mixes cost at the Gold tier:

| Example run | Companies | Reviews | Gold total |
|-------------|-----------|---------|-----------|
| 100 companies, no reviews | 100 | 0 | $0.22 |
| 100 companies × ~20 reviews | 100 | 2,000 | $1.32 |
| 1,000 companies × ~20 reviews | 1,000 | 20,000 | $13.20 |
| Companies only | 10,000 | 0 | $22.00 |

No compute or time-based charges — you pay per company and per review collected, plus a small fixed per-run start fee. Platform fees depend on your Apify plan.

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Zapier** / **Make** / **n8n** — Workflow automation
- **Google Sheets** — Direct spreadsheet export
- **Slack** / **Email** — Notifications on new results
- **Webhooks** — Trigger custom APIs on run completion
- **Apify API** — Full programmatic access

### Legal & Ethical Use

This actor collects publicly available employer-profile and review data from GoWork France for legitimate HR research, employer-brand monitoring, recruitment analysis, and lead enrichment. Reviews and reply threads may contain personal data — handle it responsibly, respect privacy and GDPR obligations, and honor data-subject rights. Users are responsible for complying with applicable laws and GoWork's Terms of Service. Do not use extracted data for spam, harassment, or any illegal purpose.

# Actor input Schema

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

Paste one or more GoWork France URLs — company profile pages, search result pages, or listing pages. This is the most precise way to scrape exactly the companies you want. Leave blank to use the search terms below.

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

Free-text company searches, for example 'Renault', 'Carrefour', or 'boulangerie Paris'. Each term runs a GoWork France search and collects the matching companies — no manual URL lookup needed.

## `maxCompanies` (type: `integer`):

Cap on the total number of companies collected across all URLs and search terms. Default 100. Set to 0 for no cap. The actor stops queuing new companies once the cap is reached.

## `includeReviews` (type: `boolean`):

Collect each company's employee reviews (rating, text, reviewer, date, and any replies). Turn off for faster, cheaper runs that return only company profiles and firmographics with no reviews.

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

Cap on the number of reviews captured per company (most recent first). Default 0 = all reviews, capped at a 2000-review safety ceiling per company. Some major French employers have thousands of reviews; set a positive number to limit how many you collect per company and cap your cost. Each review is returned as its own result. Ignored when 'Include Reviews' is off.

## `onlyRatedReviews` (type: `boolean`):

Keep only reviews that carry a 1–5 star rating. Turn on to exclude text-only comments and question-and-answer threads. Ignored when 'Include Reviews' is off.

## `reviewsStartDate` (type: `string`):

Only collect reviews published on or after this date. Use the format YYYY-MM-DD, for example 2024-01-15. Leave blank to collect all reviews regardless of date. Ignored when 'Include Reviews' is off.

## Actor input object example

```json
{
  "startUrls": [],
  "searchQueries": [
    "Carrefour"
  ],
  "maxCompanies": 100,
  "includeReviews": true,
  "maxReviewsPerCompany": 0,
  "onlyRatedReviews": false
}
```

# Actor output Schema

## `overview` (type: `string`):

Every record from the run in one place — companies and reviews — distinguished by `recordType`.

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

Companies only, with name, address, firmographics, overall rating, and review count.

## `reviews` (type: `string`):

Employee reviews only, linking each review to its company. Present only when 'Include Reviews' is enabled.

# 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": [],
    "searchQueries": [
        "Carrefour"
    ],
    "maxCompanies": 100,
    "includeReviews": true,
    "maxReviewsPerCompany": 0,
    "onlyRatedReviews": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/gowork-fr-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": [],
    "searchQueries": ["Carrefour"],
    "maxCompanies": 100,
    "includeReviews": True,
    "maxReviewsPerCompany": 0,
    "onlyRatedReviews": False,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/gowork-fr-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": [],
  "searchQueries": [
    "Carrefour"
  ],
  "maxCompanies": 100,
  "includeReviews": true,
  "maxReviewsPerCompany": 0,
  "onlyRatedReviews": false
}' |
apify call solidcode/gowork-fr-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "GoWork France Company & Reviews Scraper",
        "description": "[💰 $1.6 / 1K] Extract company profiles and employee reviews from GoWork France (gowork.fr): name, address, website, firmographics (tax ID, capital, employees, founding date), ratings, and full reviews as separate rows. Search by company name or URL. For employer research and reputation monitoring.",
        "version": "1.0",
        "x-build-id": "K3xkYa3lLjlX0WLu5"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~gowork-fr-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-gowork-fr-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/solidcode~gowork-fr-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-gowork-fr-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/solidcode~gowork-fr-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-gowork-fr-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",
                "properties": {
                    "startUrls": {
                        "title": "GoWork URLs",
                        "type": "array",
                        "description": "Paste one or more GoWork France URLs — company profile pages, search result pages, or listing pages. This is the most precise way to scrape exactly the companies you want. Leave blank to use the search terms below.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchQueries": {
                        "title": "Search Terms",
                        "type": "array",
                        "description": "Free-text company searches, for example 'Renault', 'Carrefour', or 'boulangerie Paris'. Each term runs a GoWork France search and collects the matching companies — no manual URL lookup needed.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxCompanies": {
                        "title": "Max Companies",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Cap on the total number of companies collected across all URLs and search terms. Default 100. Set to 0 for no cap. The actor stops queuing new companies once the cap is reached.",
                        "default": 100
                    },
                    "includeReviews": {
                        "title": "Include Reviews",
                        "type": "boolean",
                        "description": "Collect each company's employee reviews (rating, text, reviewer, date, and any replies). Turn off for faster, cheaper runs that return only company profiles and firmographics with no reviews.",
                        "default": true
                    },
                    "maxReviewsPerCompany": {
                        "title": "Max Reviews Per Company",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Cap on the number of reviews captured per company (most recent first). Default 0 = all reviews, capped at a 2000-review safety ceiling per company. Some major French employers have thousands of reviews; set a positive number to limit how many you collect per company and cap your cost. Each review is returned as its own result. Ignored when 'Include Reviews' is off.",
                        "default": 0
                    },
                    "onlyRatedReviews": {
                        "title": "Only Rated Reviews",
                        "type": "boolean",
                        "description": "Keep only reviews that carry a 1–5 star rating. Turn on to exclude text-only comments and question-and-answer threads. Ignored when 'Include Reviews' is off.",
                        "default": false
                    },
                    "reviewsStartDate": {
                        "title": "Reviews From Date",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Only collect reviews published on or after this date. Use the format YYYY-MM-DD, for example 2024-01-15. Leave blank to collect all reviews regardless of date. Ignored when 'Include Reviews' is off."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```