# EU Salary Benchmark — Real Disclosed Salaries by Role & Country (`studio-amba/eu-salary-benchmark`) Actor Runs our own StepStone (DE/AT/NL), Karriere.at, HelloWork, Reed, Pracuj, InfoJobs, Jobat and IrishJobs scrapers, keeps only postings with a disclosed salary, converts to annual EUR, and reports p25/median/p75 per country plus the raw datapoints. - **URL**: https://apify.com/studio-amba/eu-salary-benchmark.md - **Developed by:** [Studio Amba](https://apify.com/studio-amba) (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 This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events. Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event ## What's an Apify Actor? Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases. In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours, and optionally produces a well-defined JSON output, datasets with results, or files in key-value store. In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server. Actors are written with capital "A". ## How to integrate an Actor? If asked about integration, you help developers integrate Actors into their projects. You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready. The best way to integrate Actors is as follows. In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md): ```bash npm install apify-client ``` In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md): ```bash pip install apify-client ``` In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md): ````bash # MacOS / Linux curl -fsSL https://apify.com/install-cli.sh | bash # Windows irm https://apify.com/install-cli.ps1 | iex ```bash In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md). If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md). For usage examples, see the [API](#api) section below. For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt). # README ## EU Salary Benchmark Give it a role and a list of European countries. This actor runs our own StepStone (Germany, Austria, Netherlands), Karriere.at, HelloWork, Reed, Pracuj, InfoJobs, Jobat and IrishJobs scrapers, keeps **only the postings that disclose a salary**, converts every disclosed figure to annual EUR, and reports p25/median/p75 per country — plus one pooled EU row when you query more than one country. It does not scrape a website itself. It fans out to our own job-board scrapers, normalizes each board's salary field (structured min/max or raw text, different currency, different pay period), drops the postings that don't publish a number at all, and computes real percentiles from what's left. ### Why use this actor? Most salary "benchmark" data online is self-reported survey data (Glassdoor, Levels.fyi) or aggregated by a vendor with no visible methodology. This actor works from job postings that literally state a number — you can click through to every datapoint behind a percentile and see the exact listing it came from. - **Recruiters and hiring managers** benchmarking an offer against what's actually posted in the market right now, not a survey average from six months ago. - **Job seekers** checking whether a range they were offered is above or below p25/median/p75 for the same role in the same country. - **Compensation and People teams** doing a quick market check across multiple countries in one call instead of manually reading job boards. - **Labor-market researchers** studying salary disclosure itself — this actor surfaces the disclosure rate as a first-class output, not a footnote. ### Disclosure rate is the story, not a footnote Salary transparency varies enormously by country and is not evenly distributed. Austria is the standout: a 2023 law requires job ads to state a salary range, so both StepStone Austria and Karriere.at show disclosure rates well above 50% in most runs. Germany has no such requirement and disclosure on StepStone Germany is typically in the single digits. This actor doesn't paper over that — every report row includes `rawPostingsScanned` and `disclosureRatePct`, and a country with 0 disclosed postings still gets a row with `sampleSize: 0` rather than being silently dropped. That absence is itself the finding. ### How to scrape European salary data 1. Enter a **Role** — a job title (e.g. `software engineer`, `accountant`, `data analyst`). It's passed as-is to every selected board's own search. 2. Optionally set **Countries** to restrict which boards run. Leave empty to query all 9. Austria runs two boards (StepStone + Karriere.at) since it has by far the best disclosure rate. 3. Set **Max Per Board** higher for a bigger, more reliable sample — remember only a fraction of postings disclose a salary at all, so the useful sample is smaller than this number. 4. Run the actor. All selected boards run in parallel, so adding countries doesn't multiply run time. 5. Open the dataset. Each row is one role/country percentile report. Sort on `disclosureRatePct` to see where salary transparency is actually highest. 6. Check `RUN_SUMMARY` in the key-value store for run-level stats: boards queried, boards failed, total disclosed datapoints. ### Input | Field | Type | Description | |-------|------|-------------| | `role` | string | Job title/role to benchmark. Defaults to `"software engineer"`. | | `countries` | array | Filter which country boards to query: `DE`, `AT`, `NL`, `FR`, `GB`, `PL`, `ES`, `BE`, `IE`. Empty means all 9. | | `maxPerBoard` | integer | Maximum postings to fetch per board before filtering to salary-disclosed ones (5-200, default 30). | | `includeDatapoints` | boolean | Attach the individual normalized salary observations behind each report as a nested array (default `true`). | | `timeoutPerBoardSecs` | integer | Max seconds to wait for each underlying board scraper before treating it as failed (30-600, default 120). | | `proxyConfiguration` | object | Proxy settings passed to the underlying board scrapers. Leave default — each board otherwise falls back to its own known-good country-pinned residential proxy. | #### Example input ```json { "role": "software engineer", "countries": ["AT", "DE"], "maxPerBoard": 30 } ```` ### Output Each row is one percentile report for a role in one country (or the pooled `EU` row). | Field | Type | Description | |-------|------|-------------| | `role` | string | The role this report was built for | | `country` | string | ISO2 country code, or `EU` for the pooled report | | `region` | string | Full country name, or "European Union (pooled)" for the EU row | | `currency` | string | Always `EUR` — everything is converted/annualized | | `sampleSize` | integer | Postings with a disclosed salary this report is built from. Can be 0 — that's real data too | | `rawPostingsScanned` | integer | Total postings fetched before filtering for disclosed salary | | `disclosureRatePct` | number | `sampleSize / rawPostingsScanned` as a percentage | | `p25Eur` / `medianEur` / `p75Eur` | number | Percentiles in EUR/year. Null when sampleSize is 0 | | `minEur` / `maxEur` | number | Lowest/highest annualized datapoint in the sample | | `boardsSampled` | array | Job boards that contributed to this report | | `datapoints` | array | The individual normalized observations behind the percentiles (when `includeDatapoints` is on) | | `scrapedAt` | string | ISO timestamp of collection | #### Example output ```json { "role": "software engineer", "country": "AT", "region": "Austria", "currency": "EUR", "sampleSize": 10, "rawPostingsScanned": 16, "disclosureRatePct": 62.5, "p25Eur": 42000, "medianEur": 49200, "p75Eur": 54543, "minEur": 32729, "maxEur": 60000, "boardsSampled": ["StepStone Austria", "Karriere.at"], "scrapedAt": "2026-07-20T08:38:55.077Z" } ``` ### Board roster Only boards whose own dataset exposes a salary field are included — Jobs.ch, JobUp.ch, Jobindex and EURES were dropped from this roster because they don't scrape salary at all and can never contribute a datapoint. | Country | Board | Currency | Typical disclosure | |---------|-------|----------|---------------------| | Austria (AT) | StepStone Austria + Karriere.at | EUR | High — salary disclosure is legally mandated | | Germany (DE) | StepStone Germany | EUR | Low — no disclosure requirement | | Netherlands (NL) | StepStone Netherlands | EUR | Moderate | | France (FR) | HelloWork | EUR | Moderate | | United Kingdom (GB) | Reed | GBP -> EUR | High — structured salary field on almost every listing | | Poland (PL) | Pracuj.pl | PLN -> EUR | Moderate | | Spain (ES) | InfoJobs | EUR | Moderate | | Belgium (BE) | Jobat | EUR | Low | | Ireland (IE) | IrishJobs | EUR | Moderate — some listings explicitly say "Not Disclosed" | ### Salary normalization assumptions Every board formats salary differently — some give structured min/max numbers with a currency and pay period, most just show raw text. This actor: 1. **Prefers structured fields** (Reed's `salaryFrom`/`salaryTo`/`salaryCurrency`/`salaryPeriod`, HelloWork's and Pracuj's equivalents, StepStone's schema.org `baseSalary`) when the board exposes them. 2. **Falls back to parsing the raw text** otherwise, detecting currency (`€`/`EUR`, `£`/`GBP`, `PLN`/`zł`) and pay period from multilingual markers (`jährlich`/`per annum`/`annuel` = year; `monatlich`/`per month`/`mois` = month; `stündlich`/`per hour`/`heure` = hour). 3. **Assumes a documented default pay period per market** when neither a structured field nor a text marker names one: DE/AT/NL/BE = monthly gross (DACH/Benelux convention), FR/ES/GB/IE = annual gross (their listings, when they state a period at all, are almost always annual), PL = monthly gross. 4. **Annualizes** using 12 months/year, 2080 hours/year (40h x 52 weeks), 220 working days/year, 52 weeks/year. 5. **Converts to EUR** using live ECB rates (via Frankfurter, refreshed every run) for GBP and PLN, with an approximate fallback rate if the live fetch fails so a network hiccup never kills the run. 6. **Drops implausible datapoints** — anything annualizing below €5,000/year or above €400,000/year is treated as a parsing error and excluded, not counted. 7. When a posting gives a min and a max, the **midpoint** is used as the single representative value. **One important caveat for Austria:** many Austrian postings state "ab X monatlich" (from X per month) — that's the legal minimum the employer is required to disclose under the KV (collective agreement), not necessarily what they'll actually pay. Real offers are often higher. Treat the Austrian percentiles as a documented floor, not a ceiling. ### Boards behind this actor Each board also runs standalone if you need full-catalogue coverage or vacancy details beyond salary: - [StepStone Germany](https://apify.com/studio-amba/stepstone-de) - [StepStone Austria](https://apify.com/studio-amba/stepstone-at) - [Reed](https://apify.com/studio-amba/reed-scraper) - [Pracuj.pl](https://apify.com/studio-amba/pracuj-scraper) See also [EU Vacancy Feed](https://apify.com/studio-amba/eu-vacancy-feed) for a broader 13-board vacancy aggregator (all postings, deduplicated, salary included when disclosed but not the focus). ### FAQ **Does this actor scrape the job boards itself?** No. It calls our own StepStone, Karriere.at, HelloWork, Reed, Pracuj, InfoJobs, Jobat and IrishJobs scrapers and filters/normalizes their output. **Why is `sampleSize` 0 for some countries?** Most European job boards don't publish salary — it's negotiated after contact. A `sampleSize: 0` row is a real, correct result for a low-disclosure market (Germany, Belgium) run with a small `maxPerBoard`. Raise `maxPerBoard` for a bigger raw sample, but the ceiling is the market's real disclosure rate, not this actor. **Why did a board return 0 raw postings?** Job board anti-bot protection is intermittent — a board can 403 one run and work fine the next (Jobat in particular). A single failing board never blocks the run; check `boardsFailed` in `RUN_SUMMARY`. **How is the "EU" pooled row different from a country row?** It's the percentiles computed across every disclosed datapoint from every queried country in one run, not an average of the country medians. It only appears when 2+ countries were queried. **Can I get the raw postings instead of just the percentiles?** Yes — turn on `includeDatapoints`. Each report row then includes a `datapoints` array with the board, title, company, location, raw salary text and the URL for every posting that fed the percentiles. ### Limitations - Salary figures are converted at the FX rate active when the actor ran, not the rate at posting time. - Pay-period detection falls back to a documented market convention when a board gives neither a structured period field nor a text marker — see "Salary normalization assumptions" above. - Sample sizes are small by nature (this is filtered, disclosed-salary data, not the full job market) — treat single-digit samples as directional, not statistically robust. - Data is scraped from public job board listings and may change without notice. # Actor input Schema ## `role` (type: `string`): Job title or role to benchmark (e.g. 'software engineer', 'accountant', 'data analyst'). Passed as-is to every selected board's own search — an English tech term usually matches on most boards, but a local-language term gets more results on boards like Pracuj (Polish) or InfoJobs (Spanish). ## `countries` (type: `array`): Which country boards to query. Leave empty to query all 9. Austria runs two boards (StepStone + Karriere.at) since Austrian law mandates salary disclosure — it has by far the best coverage. ## `maxPerBoard` (type: `integer`): Maximum postings to fetch from each board before filtering to salary-disclosed ones. Salary disclosure is partial (5-90% depending on the board/country), so a higher number here gives a bigger, more reliable sample. Only postings WITH a salary count toward the percentiles. ## `includeDatapoints` (type: `boolean`): Attach the individual normalized salary observations behind each percentile report as a nested array. Turn off for a lighter dataset if you only need the aggregates. ## `timeoutPerBoardSecs` (type: `integer`): Maximum time to wait for each underlying board scraper to finish. A slow board is skipped after this and reported as failed rather than blocking the whole run. ## `proxyConfiguration` (type: `object`): Proxy settings passed to the underlying board scrapers. Leave default (Apify Residential) for reliable results — each board otherwise uses its own known-good country-pinned residential proxy. ## Actor input object example ```json { "role": "software engineer", "countries": [ "AT", "DE" ], "maxPerBoard": 15, "includeDatapoints": true, "timeoutPerBoardSecs": 120, "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": [ "RESIDENTIAL" ] } } ``` # 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 '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = { "role": "software engineer", "countries": [ "AT", "DE" ], "maxPerBoard": 15, "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": [ "RESIDENTIAL" ] } }; // Run the Actor and wait for it to finish const run = await client.actor("studio-amba/eu-salary-benchmark").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 '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = { "role": "software engineer", "countries": [ "AT", "DE", ], "maxPerBoard": 15, "proxyConfiguration": { "useApifyProxy": True, "apifyProxyGroups": ["RESIDENTIAL"], }, } # Run the Actor and wait for it to finish run = client.actor("studio-amba/eu-salary-benchmark").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 '{ "role": "software engineer", "countries": [ "AT", "DE" ], "maxPerBoard": 15, "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": [ "RESIDENTIAL" ] } }' | apify call studio-amba/eu-salary-benchmark --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "command": "npx", "args": [ "mcp-remote", "https://mcp.apify.com/?tools=studio-amba/eu-salary-benchmark", "--header", "Authorization: Bearer " ] } } } ``` ## OpenAPI specification ```json { "openapi": "3.0.1", "info": { "title": "EU Salary Benchmark — Real Disclosed Salaries by Role & Country", "description": "Runs our own StepStone (DE/AT/NL), Karriere.at, HelloWork, Reed, Pracuj, InfoJobs, Jobat and IrishJobs scrapers, keeps only postings with a disclosed salary, converts to annual EUR, and reports p25/median/p75 per country plus the raw datapoints.", "version": "0.1", "x-build-id": "zQIw2znozTW6r904i" }, "servers": [ { "url": "https://api.apify.com/v2" } ], "paths": { "/acts/studio-amba~eu-salary-benchmark/run-sync-get-dataset-items": { "post": { "operationId": "run-sync-get-dataset-items-studio-amba-eu-salary-benchmark", "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/studio-amba~eu-salary-benchmark/runs": { "post": { "operationId": "runs-sync-studio-amba-eu-salary-benchmark", "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/studio-amba~eu-salary-benchmark/run-sync": { "post": { "operationId": "run-sync-studio-amba-eu-salary-benchmark", "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": { "role": { "title": "Role", "type": "string", "description": "Job title or role to benchmark (e.g. 'software engineer', 'accountant', 'data analyst'). Passed as-is to every selected board's own search — an English tech term usually matches on most boards, but a local-language term gets more results on boards like Pracuj (Polish) or InfoJobs (Spanish).", "default": "software engineer" }, "countries": { "title": "Countries", "type": "array", "description": "Which country boards to query. Leave empty to query all 9. Austria runs two boards (StepStone + Karriere.at) since Austrian law mandates salary disclosure — it has by far the best coverage.", "items": { "type": "string", "enum": [ "DE", "AT", "NL", "FR", "GB", "PL", "ES", "BE", "IE" ], "enumTitles": [ "Germany (StepStone)", "Austria (StepStone + Karriere.at)", "Netherlands (StepStone)", "France (HelloWork)", "United Kingdom (Reed)", "Poland (Pracuj.pl)", "Spain (InfoJobs)", "Belgium (Jobat)", "Ireland (IrishJobs)" ] } }, "maxPerBoard": { "title": "Max Per Board", "minimum": 5, "maximum": 200, "type": "integer", "description": "Maximum postings to fetch from each board before filtering to salary-disclosed ones. Salary disclosure is partial (5-90% depending on the board/country), so a higher number here gives a bigger, more reliable sample. Only postings WITH a salary count toward the percentiles.", "default": 30 }, "includeDatapoints": { "title": "Include Raw Datapoints", "type": "boolean", "description": "Attach the individual normalized salary observations behind each percentile report as a nested array. Turn off for a lighter dataset if you only need the aggregates.", "default": true }, "timeoutPerBoardSecs": { "title": "Timeout Per Board (seconds)", "minimum": 30, "maximum": 600, "type": "integer", "description": "Maximum time to wait for each underlying board scraper to finish. A slow board is skipped after this and reported as failed rather than blocking the whole run.", "default": 120 }, "proxyConfiguration": { "title": "Proxy Configuration", "type": "object", "description": "Proxy settings passed to the underlying board scrapers. Leave default (Apify Residential) for reliable results — each board otherwise uses its own known-good country-pinned residential proxy." } } }, "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 } } } } } } } } } } ```