# StepStone Scraper - Europe Jobs Data (`benthepythondev/stepstone-scraper`) Actor

Scrape StepStone job listings (Germany, UK, Austria, Belgium, Netherlands): job title, company, location, posted date, remote/work-from-home flag, salary and listing URL. Search by keyword, location or StepStone URL.

- **URL**: https://apify.com/benthepythondev/stepstone-scraper.md
- **Developed by:** [Ben](https://apify.com/benthepythondev) (community)
- **Categories:** Jobs, Business, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## 💼 StepStone Scraper - Europe Jobs Data

Scrape job listings from **StepStone**, one of Europe's largest job boards, in a single run. Get the job title, hiring company, location, posted date, remote / work-from-home flag, salary (where shown) and the direct listing URL for every result in your search — across Germany, the UK, Austria, Belgium and the Netherlands. Export to JSON/CSV/Excel, run on a schedule, call via API, or connect to Make, Zapier or n8n.

### 🔎 What is the StepStone Scraper?

StepStone lists hundreds of thousands of vacancies across Europe. This actor turns any StepStone search into clean, structured data — no account and no API key. Filter on the site (keyword, location, contract type), paste the search URL, and the actor returns one row per job, paginating automatically until it reaches your limit. You can also just give a keyword, a location and a country and it builds the search for you.

#### What data does it extract?

- **Job title**
- **Company** (the hiring employer — great for lead generation and market mapping)
- **Location** (city / region, including multi-city listings)
- **Posted date** (relative, e.g. "2 days ago")
- **Work-from-home / remote flag**
- **Salary** where StepStone displays it
- **Company logo** URL
- **Direct job URL** and a stable **job ID**

### ⬇️ Input

| Field | Type | Description |
|-------|------|-------------|
| `searchUrls` | array | StepStone search-results URLs to scrape exactly. |
| `keyword` | string | Job title / keyword (used if no URLs are given). |
| `location` | string | Optional city/region to combine with the keyword. |
| `domain` | string | Country site: stepstone.de / .co.uk / .at / .be / .nl. |
| `maxResults` | integer | Max jobs to return per search (default 50). |

#### Example input

```json
{
  "keyword": "data engineer",
  "location": "Berlin",
  "domain": "www.stepstone.de",
  "maxResults": 50
}
````

### ⬆️ Output

Each item looks like this:

```json
{
  "job_id": "14206383",
  "title": "Data Engineer – CRM (m/w/d)",
  "company": "R+V Allgemeine Versicherung AG",
  "location": "Wiesbaden",
  "url": "https://www.stepstone.de/stellenangebote--Data-Engineer-CRM-m-w-d-Wiesbaden--14206383-inline.html",
  "posted": "vor 2 Tagen",
  "work_from_home": true,
  "salary": null,
  "company_logo": "https://cdn-images.stepstone.com/...",
  "search": "https://www.stepstone.de/jobs/data-engineer"
}
```

### 💡 Use cases

- 🧭 **Job market research** — track demand, hiring companies and remote availability for any role or region across Europe.
- 📇 **Recruitment & lead gen** — build lists of companies actively hiring for a skill set for sourcing and sales outreach.
- 📊 **Salary & trend analysis** — feed listings into dashboards to monitor titles, locations and posting velocity over time.
- 🔔 **Job alerts & aggregation** — schedule the actor to capture fresh postings daily and pipe them into your own board or CRM.

### 📈 Why scrape StepStone?

StepStone is one of the strongest job-market signals in Europe, especially for Germany and DACH hiring. A company posting on StepStone is actively spending budget to fill a role, which makes the data useful far beyond job search. Recruiters can identify employers with open headcount, sales teams can spot companies investing in specific departments, and market researchers can measure demand for skills such as Python, SAP, logistics, nursing, engineering or finance.

Unlike broad web search results, StepStone listings are structured around employer, role and location. That makes the output easy to segment by region, keyword, remote availability and company. You can run the same search daily, compare new records against yesterday's dataset and build a reliable hiring signal without maintaining your own crawler.

### 🔁 Automation workflow

For a simple monitoring setup, create one task per market: for example `data engineer in Berlin`, `nurse in Hamburg`, or `sales manager in Munich`. Schedule each task daily and send the dataset to Google Sheets, Airtable, Notion or a CRM. Use the job URL or `job_id` as the unique key, then mark new records as fresh openings.

For lead generation, combine StepStone with a company-enrichment actor. The StepStone scraper gives you the hiring company and role; a contact extractor can turn the company website into emails, phone numbers and social profiles. That gives you a complete pipeline from hiring intent to outreach-ready leads.

### ✅ Data quality notes

The actor reads server-rendered StepStone result cards, not screenshots. It removes style/script noise before parsing, de-duplicates jobs by stable ID or URL, and returns null when a field is not shown instead of inventing values. Salary is included only where StepStone displays it on the results page. Some jobs are multi-location or remote-friendly; keep the original `location` text and `work_from_home` flag together when analyzing remote availability.

### ❓ FAQ

**Do I need a StepStone account or API key?** No. Just paste a search URL, or give a keyword + location.

**Which countries are supported?** Germany (stepstone.de), the UK (stepstone.co.uk), Austria, Belgium and the Netherlands. Paste any StepStone country URL.

**How do I get a search URL?** Search and filter on StepStone as usual, then copy the URL from your browser's address bar.

**How many jobs can it return?** As many as your search contains; set `maxResults` to cap it. The actor paginates automatically.

**Does it return the hiring company?** Yes — the employer name is included for every job, which is ideal for lead generation.

**Is salary always included?** Only when StepStone shows it on the results page; otherwise the field is null.

**How fresh is the data?** It is scraped live from StepStone when you run the actor. Schedule it for a daily dataset.

**In what format can I export?** JSON, CSV, Excel, or via the Apify API and integrations (Make, Zapier, n8n).

**Is it legal?** The actor collects only publicly available job-listing information. You are responsible for using the data in line with StepStone's terms and applicable laws (including GDPR for any personal data).

### 🔗 You might also like

- 💼 Glassdoor, TheMuse & Naukri job scrapers
- 🧑‍💻 Dice, ZipRecruiter & CareerBuilder job scrapers
- 🏢 Greenhouse, Lever & Workday ATS scrapers
- 📨 Website Contact Extractor for company lead enrichment

**Keywords:** stepstone scraper, stepstone jobs, stepstone api, scrape stepstone, europe jobs data, germany jobs scraper, uk jobs, job board scraper, recruitment data, hiring companies, jobs dataset, stepstone.de, vacancy scraper, employment data, job listings api, apify jobs.

# Actor input Schema

## `searchUrls` (type: `array`):

Paste StepStone search-results URLs (stepstone.de, stepstone.co.uk, stepstone.at, stepstone.be, stepstone.nl). Filter on the site, then copy the URL. Leave empty to use keyword + location below.

## `keyword` (type: `string`):

Job title or keyword to search (used if no search URLs given), e.g. 'python developer'.

## `location` (type: `string`):

Optional city/region to combine with the keyword, e.g. 'Berlin'.

## `domain` (type: `string`):

Which StepStone country site to use for the keyword search.

## `maxResults` (type: `integer`):

Maximum number of jobs to return per search URL/keyword.

## Actor input object example

```json
{
  "searchUrls": [
    "https://www.stepstone.de/jobs/data-engineer"
  ],
  "domain": "www.stepstone.de",
  "maxResults": 25
}
```

# 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 = {
    "searchUrls": [
        "https://www.stepstone.de/jobs/data-engineer"
    ],
    "domain": "www.stepstone.de",
    "maxResults": 25
};

// Run the Actor and wait for it to finish
const run = await client.actor("benthepythondev/stepstone-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 = {
    "searchUrls": ["https://www.stepstone.de/jobs/data-engineer"],
    "domain": "www.stepstone.de",
    "maxResults": 25,
}

# Run the Actor and wait for it to finish
run = client.actor("benthepythondev/stepstone-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 '{
  "searchUrls": [
    "https://www.stepstone.de/jobs/data-engineer"
  ],
  "domain": "www.stepstone.de",
  "maxResults": 25
}' |
apify call benthepythondev/stepstone-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "StepStone Scraper - Europe Jobs Data",
        "description": "Scrape StepStone job listings (Germany, UK, Austria, Belgium, Netherlands): job title, company, location, posted date, remote/work-from-home flag, salary and listing URL. Search by keyword, location or StepStone URL.",
        "version": "1.0",
        "x-build-id": "aVhIGD4K58P0Lsllg"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/benthepythondev~stepstone-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-benthepythondev-stepstone-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/benthepythondev~stepstone-scraper/runs": {
            "post": {
                "operationId": "runs-sync-benthepythondev-stepstone-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/benthepythondev~stepstone-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-benthepythondev-stepstone-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": {
                    "searchUrls": {
                        "title": "StepStone search URLs",
                        "type": "array",
                        "description": "Paste StepStone search-results URLs (stepstone.de, stepstone.co.uk, stepstone.at, stepstone.be, stepstone.nl). Filter on the site, then copy the URL. Leave empty to use keyword + location below.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "keyword": {
                        "title": "Keyword / job title",
                        "type": "string",
                        "description": "Job title or keyword to search (used if no search URLs given), e.g. 'python developer'."
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Optional city/region to combine with the keyword, e.g. 'Berlin'."
                    },
                    "domain": {
                        "title": "StepStone domain",
                        "enum": [
                            "www.stepstone.de",
                            "www.stepstone.co.uk",
                            "www.stepstone.at",
                            "www.stepstone.be",
                            "www.stepstone.nl"
                        ],
                        "type": "string",
                        "description": "Which StepStone country site to use for the keyword search.",
                        "default": "www.stepstone.de"
                    },
                    "maxResults": {
                        "title": "Max results per search",
                        "minimum": 1,
                        "maximum": 2000,
                        "type": "integer",
                        "description": "Maximum number of jobs to return per search URL/keyword.",
                        "default": 50
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
