# StepStone Jobs Scraper — Salary, Company & Full Job Details (`haketa/stepstone-scraper`) Actor

Scrape job listings from StepStone across DACH & Benelux — title, company, location, salary, contract type, description and apply URL.

- **URL**: https://apify.com/haketa/stepstone-scraper.md
- **Developed by:** [Haketa](https://apify.com/haketa) (community)
- **Categories:** Jobs, Lead generation
- **Features:** Limited permissions
- **Stats:** 4 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.29 / 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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## StepStone Jobs Scraper — Salary, Company & Full Job Details

[![Apify Actor](https://img.shields.io/badge/Apify-Actor-0066CC?style=for-the-badge\&logo=apify\&logoColor=white)](https://apify.com/haketa/stepstone-scraper)
[![StepStone DE & AT](https://img.shields.io/badge/StepStone-Germany%20%26%20Austria-FF6600?style=for-the-badge)](https://www.stepstone.de)
[![Structured Salary](https://img.shields.io/badge/Includes-Salary%20Min%20%2F%20Max%20EUR-16A34A?style=for-the-badge)]()
[![Scale](https://img.shields.io/badge/Scale-1%2C000%2B%20Jobs%20Pagination-7C3AED?style=for-the-badge)]()
[![Export](https://img.shields.io/badge/Export-JSON%20%7C%20CSV%20%7C%20Excel%20%7C%20API-0F172A?style=for-the-badge)]()

**Scrape job listings from [StepStone](https://www.stepstone.de)** — the #1 job board in Germany (`stepstone.de`) and Austria (`stepstone.at`) — as clean, structured data with **no login and no coding**. This **StepStone scraper** searches by keyword and location (or follows your own filtered StepStone URLs) and extracts the job title, hiring company, location, **structured salary range (`salaryMin`, `salaryMax`, `salaryCurrency`, `salaryPeriod`)**, contract type, remote/hybrid work model, **full job description**, benefits, ISO posting date, company profile, and application link for every result.

Unlike basic job scrapers that only grab a title and company name from search cards, this **StepStone data extractor** opens each job posting to capture the **complete hiring intelligence record** — including structured compensation ranges that ~86–93% of listings expose. Export to **JSON, CSV, Excel, or API** for recruitment pipelines, B2B lead generation, salary benchmarking, and DACH labor-market intelligence.

***

### ⚡ At a glance

| Feature | Details |
| :--- | :--- |
| **Target domains** | `stepstone.de` (Germany), `stepstone.at` (Austria) + any filtered StepStone URL via `startUrls` |
| **Search modes** | Keyword + City dropdown / Custom location + Radius (`km`), Search URLs, or Direct Job URLs |
| **Extracted fields** | **36 structured fields** per job — identity, company, location, structured salary, contract/remote model, full text, dates & apply link |
| **Salary intelligence** | `salary` (formatted), `salaryMin`, `salaryMax`, `salaryCurrency` (`EUR`), `salaryPeriod` (`Jahr`/`Monat`), `salaryPredicted` (`true`/`false`) |
| **Detail enrichment** | Toggle `scrapeDetails: true` (default) for full description + salary + benefits, or `false` for high-speed list overview |
| **Pagination & scale** | Automatic multi-page pagination (`?page=N`, ~25 jobs/page) + multi-city/keyword expansion for **1,000+ results** |
| **Deduplication** | 100% deduplicated in-memory by canonical `jobId` across all pages and searches |
| **Export formats** | JSON, JSONL, CSV, Excel (`.xlsx`), HTML, XML, RSS, and REST API |

***

### 🔎 Why scrape StepStone?

**StepStone** is the dominant recruitment marketplace across the German-speaking DACH region, hosting hundreds of thousands of active vacancies from Mittelstand leaders, DAX enterprises, tech startups, and staffing agencies. Every job listing is a high-intent signal: it reveals which companies are investing, what technology stacks or qualifications they need, where they are expanding, and how much they pay.

Collecting StepStone data manually does not scale. Search results are split across dozens of pages, salary ranges are tucked inside interactive components, full descriptions and benefits sit on individual detail pages, and standard datacenter requests are blocked. A dedicated **StepStone job scraper** turns the entire job board into a clean, structured dataset you can query, schedule, and pipe directly into your ATS, CRM, or analytics warehouse.

#### Common reasons teams scrape StepStone

- 🎯 **Recruiting & talent sourcing** — build a live feed of open roles for specific titles, skills, or German/Austrian cities and engage hiring managers first.
- 💶 **Salary benchmarking & compensation analytics** — analyze `salaryMin` and `salaryMax` across roles, seniority levels, industries, and regions.
- 📈 **B2B lead generation & sales prospecting** — turn actively hiring companies (`company`, `companyProfileUrl`, `industry`, `locality`, `postalCode`) into high-intent outbound prospect lists.
- 📊 **DACH labor-market & skills research** — track hiring velocity, remote/hybrid work adoption (`Homeoffice möglich`), and skill demand over time.
- 🕵️ **Competitive intelligence** — monitor competitors' open positions, department expansion, and regional hiring footprint.
- 🔁 **Job board & ATS aggregation** — ingest normalized StepStone job postings into your own job portal, career marketplace, or internal database.
- 🗓️ **Automated daily job alerts** — schedule recurring runs and deduplicate on `jobId` to surface only newly published vacancies.

***

### ✨ What this StepStone scraper does

- ✅ **Keyword + location search** across **stepstone.de** (Germany) and **stepstone.at** (Austria), with 19 major DACH cities in a one-click dropdown plus free-text `locationCustom` and `radius` (`0–100 km`).
- ✅ **Start-URL mode (`startUrls`)** — paste any StepStone search URL with custom browser filters applied (remote work, seniority, discipline, date posted, industry) or paste individual job URLs.
- ✅ **Unlocked 1,000+ deep pagination** — automatically walks through every result page (`?page=1, 2, 3…`, ~25 jobs per page) and expands across cities/keywords when `maxItems >= 1000`, governed cleanly by your `maxItems` limit.
- ✅ **Full detail-page enrichment (`scrapeDetails`)** — visits each job posting to extract the complete job description, employee benefits, structured salary bounds, contract type, work model, ISO publication/expiration dates, and direct application URL.
- ✅ **Structured compensation fields** — parses `salaryMin`, `salaryMax`, `salaryCurrency`, and `salaryPeriod` as typed fields alongside a `salaryPredicted` boolean so you can separate employer-stated pay from StepStone salary estimates.
- ✅ **Remote & home-office detection** — populates `workFromHome` (e.g. `Homeoffice möglich`, `Home-Office`) and `workType` (`Vollzeit`, `Teilzeit`) so you can filter remote-friendly positions immediately.
- ✅ **Fast list-only mode** — set `scrapeDetails: false` when you only need a rapid scan of titles, companies, locations, relative dates, and snippets.
- ✅ **Zero duplicates & timeout safety** — deduplicates every record by `jobId`, streams items to the dataset in real time, and stops gracefully before any platform timeout so your collected data is always preserved.

***

### 🎯 Use cases

| Persona | How they use StepStone Jobs Scraper |
| :--- | :--- |
| **Recruitment & Staffing Agencies** | Automate daily discovery of companies hiring for hard-to-fill engineering, healthcare (`Pflegefachkraft`), finance, and sales roles across Germany and Austria. |
| **B2B Sales & GTM Teams** | Identify growing DACH companies by their active job openings and enrich CRM pipelines with hiring company names, StepStone company profiles, cities, and industries. |
| **HR Tech & People Analytics** | Build proprietary DACH salary benchmarks using numeric `salaryMin` / `salaryMax` ranges segmented by job title, city, and industry. |
| **Job Aggregators & Career Portals** | Populate niche job boards with fresh, schema-normalized vacancies including full descriptions, benefits, company logos, and `applyUrl` links. |
| **Market & Economic Researchers** | Measure regional labor demand, contract types (`Feste Anstellung` vs `Befristeter Vertrag`), and remote-work trends across German federal states and Austrian provinces. |
| **Venture Capital & Private Equity** | Track portfolio and target-company headcount velocity by monitoring new job postings and department growth week over week. |

***

### 📥 Input parameters

Configure the Actor using the visual form in the Apify Console or pass a JSON object via the API. No field is required — an empty input `{}` automatically collects a diverse sample of popular jobs across Germany.

| Field | Type | Default | Description |
| :--- | :--- | :--- | :--- |
| `keyword` | `string` | `"software developer"` (prefill) | Job title or keyword to search (e.g. `software developer`, `pflegefachkraft`, `projektmanager`, `data analyst`). Leave empty for a mixed sample across top roles. |
| `domain` | `string` | `"de"` | Country site to search: `"de"` (`stepstone.de` Germany) or `"at"` (`stepstone.at` Austria). |
| `location` | `string` | `""` (All locations) | Dropdown of 19 major German and Austrian cities (`berlin`, `münchen`, `hamburg`, `köln`, `frankfurt-am-main`, `wien`, `graz`, etc.) or country-wide. |
| `locationCustom` | `string` | `""` | Optional free-text city, town, or region name that overrides the `location` dropdown (e.g. `karlsruhe`, `bonn`, `mannheim`, `linz`). |
| `radius` | `integer` | `0` | Search radius in kilometers (`0–100`) around the selected city. `0` keeps results strictly inside the target location. |
| `scrapeDetails` | `boolean` | `true` | Open each job detail page to extract full description, structured salary (`salaryMin`/`salaryMax`), benefits, contract type, ISO dates, and `applyUrl`. Set `false` for fast list-only mode. |
| `maxItems` | `integer` | `0` (`50` prefill) | Maximum number of unique jobs to collect. `0` = unlimited (empty filter runs cap at 100 by default). Set `1000` or higher for bulk extraction. |
| `maxPagesPerSearch` | `integer` | `0` | Maximum result pages per search query (~25 jobs per page). `0` = automatic / unlimited, governed by `maxItems`. |
| `startUrls` | `array` | `[]` | Optional list of StepStone search-result URLs (with any custom filters applied) or direct individual job posting URLs. |
| `proxyConfiguration` | `object` | DE Residential | Proxy configuration. European residential proxy (`RESIDENTIAL`, country `DE` or `AT`) is pre-configured and strongly recommended. |
| `requestDelay` | `integer` | `800` | Polite delay between requests in milliseconds (`0–20000`). |
| `maxConcurrency` | `integer` | `6` | Number of detail pages fetched in parallel (`1–20`). |

#### Example 1 — Targeted keyword & city search (Germany)

```json
{
  "keyword": "software developer",
  "location": "berlin",
  "domain": "de",
  "radius": 20,
  "scrapeDetails": true,
  "maxItems": 250,
  "maxPagesPerSearch": 0,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"],
    "apifyProxyCountry": "DE"
  }
}
```

#### Example 2 — High-volume 1,000+ job extraction

```json
{
  "keyword": "ingenieur",
  "domain": "de",
  "scrapeDetails": true,
  "maxItems": 1200,
  "maxPagesPerSearch": 0,
  "maxConcurrency": 8
}
```

#### Example 3 — Filtered StepStone search URLs (`startUrls`)

Apply any filters on StepStone in your browser (remote/home-office, seniority, full-time/part-time, posted within 7 days), copy the URL, and paste it into `startUrls`:

```json
{
  "startUrls": [
    "https://www.stepstone.de/jobs/data-engineer/in-hamburg?wfh=2",
    "https://www.stepstone.at/jobs/marketing/in-wien"
  ],
  "scrapeDetails": true,
  "maxItems": 500
}
```

#### Example 4 — Fast list-only scan (`scrapeDetails: false`)

```json
{
  "keyword": "controller",
  "location": "frankfurt-am-main",
  "scrapeDetails": false,
  "maxItems": 1000
}
```

***

### 📤 Output format & schema

Each job is saved as one normalized JSON object in the dataset. Below is a real record from a live `software developer` run:

```json
{
  "jobId": "10478856",
  "title": "Software Developer (m/w/d) Defence",
  "url": "https://www.stepstone.de/stellenangebote--Software-Developer-m-w-d-Defence-Ulm-FERCHAU-Connecting-People-and-Technologies--10478856-inline.html",
  "company": "FERCHAU – Connecting People and Technologies",
  "companyUrl": "https://www.stepstone.de/cmp/de/FERCHAU-Connecting-People-and-Technologies-6095/jobs.html",
  "companyProfileUrl": "https://www.stepstone.de/cmp/de/FERCHAU-Connecting-People-and-Technologies-6095/jobs.html",
  "companyLogo": "https://www.stepstone.de/upload_DE/logo/F/logoFERCHAU-GmbH-6095DE.gif",
  "location": "Ulm",
  "country": "DE",
  "region": null,
  "locality": "Ulm",
  "postalCode": "89077",
  "workFromHome": "Homeoffice möglich",
  "contractType": "Feste Anstellung",
  "workType": "Homeoffice möglich, Vollzeit",
  "employmentType": "FULL_TIME",
  "industry": "IT, IT-Softwareentwicklung",
  "salary": "52.000 – 80.000 EUR/Jahr (geschätzt)",
  "salaryMin": 52000,
  "salaryMax": 80000,
  "salaryCurrency": "EUR",
  "salaryPeriod": "Jahr",
  "salaryPredicted": true,
  "datePosted": "2026-11-01T03:03:07.533Z",
  "validThrough": "2026-12-29T23:34:56.393Z",
  "postedRelative": "vor 21 Stunden",
  "snippet": "FERCHAU ist eine führende europäische Plattform für Technologie-Dienstleistungen …",
  "description": "Technologischer Fortschritt gelingt nur, wenn Visionen zur Realität werden …",
  "benefits": "Faszinierende und wegweisende Entwicklung von technologischen Lösungen …",
  "applyUrl": "https://www.stepstone.de/stellenangebote--Software-Developer-m-w-d-Defence-Ulm-FERCHAU-Connecting-People-and-Technologies--10478856-inline.html",
  "directApply": true,
  "searchWhat": "software developer",
  "searchWhere": null,
  "searchDomain": "de",
  "rank": 2,
  "scrapedAt": "2026-11-02T00:33:34.856Z"
}
```

#### 🗂️ Field reference by category

##### 🆔 Job Identity & Links

| Field | Type | Coverage | Description |
| :--- | :--- | :--- | :--- |
| `jobId` | `string` | 🟢 High (100%) | Unique StepStone job identifier — stable key for cross-run deduplication. |
| `title` | `string` | 🟢 High (100%) | Full job posting title. |
| `url` | `string` | 🟢 High (100%) | Canonical StepStone job detail URL. |
| `applyUrl` | `string` | 🟢 High (~100%) | Direct application link (`scrapeDetails: true`). |
| `directApply` | `boolean` | 🟢 High (~100%) | Whether candidates can apply directly on StepStone. |

##### 🏢 Hiring Company (B2B Lead Signals)

| Field | Type | Coverage | Description |
| :--- | :--- | :--- | :--- |
| `company` | `string` | 🟢 High (100%) | Name of the hiring organization. |
| `companyUrl` | `string` | 🟡 Conditional (~73%) | Organization URL from structured job data when provided. |
| `companyProfileUrl` | `string` | 🟡 Conditional (~73%) | Link to the employer's StepStone company profile and open jobs page. |
| `companyLogo` | `string` | 🟢 High (~98%) | URL of the employer's logo image. |
| `industry` | `string` | 🟢 High (~98%) | Employer industry and job function category (`scrapeDetails: true`). |

##### 📍 Location & Geography

| Field | Type | Coverage | Description |
| :--- | :--- | :--- | :--- |
| `location` | `string` | 🟢 High (100%) | Display location string on the job card (city or multiple cities). |
| `country` | `string` | 🟢 High (100%) | ISO country code (`DE`, `AT`, etc.). |
| `locality` | `string` | 🟢 High (~95%) | Parsed city/municipality from the detail page. |
| `postalCode` | `string` | 🟡 Conditional (~45%) | Postal code (`PLZ`) when published by the employer. |
| `region` | `string` | 🟡 Conditional (<5%) | Federal state/region when explicitly included in structured address data. |

##### 💶 Compensation & Salary Intelligence

| Field | Type | Coverage | Description |
| :--- | :--- | :--- | :--- |
| `salary` | `string` | 🟢 High (~86–93%) | Formatted compensation string (e.g. `52.000 – 80.000 EUR/Jahr (geschätzt)`). |
| `salaryMin` | `integer` | 🟢 High (~86–93%) | Lower bound of the annual/monthly salary range as an integer. |
| `salaryMax` | `integer` | 🟢 High (~86–93%) | Upper bound of the annual/monthly salary range as an integer. |
| `salaryCurrency` | `string` | 🟢 High (~86–93%) | ISO currency code (typically `EUR`). |
| `salaryPeriod` | `string` | 🟢 High (~86–93%) | Pay period (`Jahr`, `Monat`, or `Stunde`). |
| `salaryPredicted` | `boolean` | 🟢 High (100%) | `true` when the range is StepStone's salary model estimate; `false` when employer-stated. |

##### 🕒 Work Model, Contract & Dates

| Field | Type | Coverage | Description |
| :--- | :--- | :--- | :--- |
| `contractType` | `string` | 🟢 High (~95%) | Contract type (e.g. `Feste Anstellung`, `Befristeter Vertrag`, `Praktikum`). |
| `workType` | `string` | 🟢 High (~95%) | Working time and remote mode (e.g. `Homeoffice möglich, Vollzeit`, `Teilzeit`). |
| `workFromHome` | `string` | 🟡 Conditional | Populated whenever remote/hybrid/home-office work is indicated (`Homeoffice möglich`). |
| `employmentType` | `string` | 🟢 High (~98%) | Normalized employment type (`FULL_TIME`, `PART_TIME`, `CONTRACTOR`, etc.). |
| `datePosted` | `string` | 🟢 High (~100%) | Exact ISO 8601 publication timestamp (`scrapeDetails: true`). |
| `validThrough` | `string` | 🟢 High (~95%) | ISO 8601 listing expiration timestamp (`scrapeDetails: true`). |
| `postedRelative` | `string` | 🟢 High (~95%) | Human-readable relative age from the search card (e.g. `vor 2 Tagen`). |

##### 📄 Job Content & Search Metadata

| Field | Type | Coverage | Description |
| :--- | :--- | :--- | :--- |
| `snippet` | `string` | 🟢 High (100%) | Short teaser text from the search result card. |
| `description` | `string` | 🟢 High (~100%) | Full plain-text job description (`scrapeDetails: true`). |
| `benefits` | `string` | 🟢 High (~95%) | Employee benefits and perks section (`scrapeDetails: true`). |
| `searchWhat` | `string` | 🟢 High | Keyword query that discovered this listing. |
| `searchWhere` | `string` | 🟡 Conditional | Location filter used for the search. |
| `searchDomain` | `string` | 🟢 High (100%) | StepStone country domain (`de`, `at`). |
| `rank` | `integer` | 🟢 High (100%) | 1-based ranking position within the search query. |
| `scrapedAt` | `string` | 🟢 High (100%) | ISO 8601 timestamp when the record was extracted. |

***

### 🔁 Pagination & 1,000+ scaling

The Actor paginates StepStone search results automatically:

- **Multi-page traversal**: For each search query, it walks page `1, 2, 3…` (`?page=N`, ~25 job cards per page) until `maxItems` is reached, `maxPagesPerSearch` is reached (when set `> 0`), or no more results exist.
- **Automatic multi-city / keyword expansion**: When `maxItems >= 1000` (with `maxPagesPerSearch: 0`), if a single search query exhausts its pages before hitting your target, the scraper automatically expands across top German (`DE`) or Austrian (`AT`) cities and popular job categories to deliver **1,000+ unique, deduplicated job listings** in a single run.
- **Global deduplication**: Every job is tracked by its numeric `jobId` in a global `Set`, ensuring **zero duplicate records** even when overlapping searches or cities are combined.

***

### 💻 How to use via API

#### Python (`apify-client`)

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_API_TOKEN")

run_input = {
    "keyword": "software developer",
    "location": "berlin",
    "domain": "de",
    "scrapeDetails": True,
    "maxItems": 200,
    "maxPagesPerSearch": 0,
}

run = client.actor("haketa/stepstone-scraper").call(run_input=run_input)

for job in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(f"{job['title']} | {job['company']} | {job['salary']} | {job['url']}")
```

#### JavaScript / Node.js (`apify-client`)

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

const client = new ApifyClient({ token: 'YOUR_APIFY_API_TOKEN' });

const run = await client.actor('haketa/stepstone-scraper').call({
    keyword: 'data engineer',
    location: 'münchen',
    domain: 'de',
    scrapeDetails: true,
    maxItems: 200,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Extracted ${items.length} StepStone jobs:`, items[0]);
```

***

### 💡 Best practices & tips

- **Keep European residential proxies enabled** — StepStone blocks standard datacenter IPs. The default `RESIDENTIAL` proxy configuration (`DE`) ensures smooth, uninterrupted extraction.
- **Leave `maxPagesPerSearch` at `0` for large runs** — setting `maxPagesPerSearch: 0` lets `maxItems` control the exact stop point, whether you want 50 jobs or 2,000+ jobs.
- **Use `scrapeDetails: false` for rapid market sizing** — list-only mode fetches 25 jobs per single HTTP request and finishes 1,000+ listings in under a minute.
- **Filter remote roles easily** — inspect `workFromHome` and `workType` for `Homeoffice möglich` or pass a pre-filtered remote URL (`?wfh=2`) in `startUrls`.
- **Schedule daily incremental runs** — combine the Apify Scheduler with webhook/Make/Zapier integrations and deduplicate on `jobId` to trigger instant alerts on newly posted roles.

***

### ⚠️ Limitations

- **Residential proxy requirement**: Because StepStone protects its pages against datacenter traffic, runs without residential proxies will fail or return 0 results.
- **Region field sparsity**: StepStone's structured address data rarely populates `region` (federal state), whereas `locality` (city), `postalCode`, and `country` are reliably populated.
- **Predicted vs. stated salaries**: When an employer does not state an explicit salary range in the ad, StepStone provides a calculated benchmark (`salaryPredicted: true`). Both are clearly distinguished in the output.

***

### ❓ FAQ

#### How many jobs can StepStone Jobs Scraper extract?

As many as your search criteria expose — from a quick 50-job sample to **1,000+ deduplicated jobs** in a single run. Set `maxPagesPerSearch: 0` and set `maxItems` to your desired total (or `0` for unlimited).

#### Does this scraper extract real salary numbers?

Yes. Whenever StepStone includes a stated or estimated compensation range on the detail page (~86–93% of listings), the Actor extracts `salary` (formatted string), `salaryMin` (integer), `salaryMax` (integer), `salaryCurrency` (`EUR`), `salaryPeriod` (`Jahr`/`Monat`), and `salaryPredicted` (`boolean`).

#### Do I need a StepStone account or cookies?

No. The scraper extracts public job listings without requiring any login, cookies, or account credentials.

#### Which StepStone countries are supported?

Direct keyword + location search supports **Germany (`stepstone.de`)** and **Austria (`stepstone.at`)**. You can also pass search or job URLs from other StepStone domains via `startUrls`.

#### How fast is a typical run?

List-only mode (`scrapeDetails: false`) collects ~25 jobs per second. Full detail mode (`scrapeDetails: true`) enriches 6 jobs concurrently by default, collecting **50 full job records in ~20–30 seconds** and **400+ full records in ~4 minutes**.

#### Can I scrape only specific job URLs?

Yes. Paste individual StepStone job posting URLs (`.../stellenangebote--...html`) into `startUrls` and the Actor will scrape their full details directly.

***

### 🔗 Related scrapers

- [SEEK Jobs Scraper (Australia & NZ, with Salary)](https://apify.com/haketa/seek-scraper)
- [ZipRecruiter Jobs & Salary Scraper (US, UK, IE, CA)](https://apify.com/haketa/ziprecruiter-scraper)
- [Workana Freelance Jobs Scraper](https://apify.com/haketa/workana-scraper)
- [H1B Visa Database Scraper](https://apify.com/haketa/h1b-visa-database-scraper)
- [GoodFirms B2B Companies & Software Scraper](https://apify.com/haketa/goodfirms-scraper)

***

### 📋 Changelog

- **v1.2 (2026-11)** — Unlocked **1,000+ deep pagination**: changed `maxPagesPerSearch` default to `0` (auto/unlimited governed by `maxItems`), removed partial-page early break, added automatic multi-city/keyword expansion for 1,000+ runs, and optimized default prefill (`maxItems: 50`) for fast `<30s` verification runs.
- **v1.1 (2026-08)** — Added automatic `workFromHome` remote/hybrid signal extraction from work-model chips and Turkish `İ/ı` input normalization.
- **v1.0 (2026-06)** — Initial release with `stepstone.de` & `stepstone.at` search, `startUrls` support, full detail enrichment, and structured `salaryMin` / `salaryMax` extraction.

# Changelog

This Actor's version history is a separate document: https://apify.com/haketa/stepstone-scraper/changelog.md

# Actor input Schema

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

The job title or keyword to search for, e.g. 'software developer', 'pflegefachkraft', 'marketing manager'. Leave empty to get a broad, mixed sample of popular jobs.

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

Which StepStone country site to search.

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

Pick a popular city to focus the search, or choose 'All locations' for a country-wide search. Need a city that is not listed? Use the 'Custom location' box below.

## `locationCustom` (type: `string`):

Optional. Type any other city or region name here to override the dropdown above, e.g. 'karlsruhe', 'bonn', 'basel'.

## `radius` (type: `integer`):

How far around the chosen location to include jobs, in kilometres. 0 keeps it tight to the city.

## `scrapeDetails` (type: `boolean`):

Open each job to add the full description, real/predicted salary, contract type, benefits, company profile, posting date and apply URL. Richer results. Turn OFF for a faster list-only run.

## `maxItems` (type: `integer`):

Maximum number of jobs to collect. Leave at 0 for no limit (an empty search is automatically capped at 100 so the sample run stays fast).

## `maxPagesPerSearch` (type: `integer`):

Maximum result pages to read per search (each page holds about 25 jobs). 0 = auto / no limit (governed by maxItems).

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

Optional. Paste StepStone search-result URLs (any country, with your own filters already applied) or individual job URLs. Most users can ignore this and use the fields above.

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

Recommended: keep European residential proxy enabled for reliable results.

## `requestDelay` (type: `integer`):

Delay between requests in milliseconds to stay polite and reliable.

## `maxConcurrency` (type: `integer`):

How many detail pages to fetch in parallel. Keep moderate for reliable results.

## Actor input object example

```json
{
  "keyword": "software developer",
  "domain": "de",
  "location": "",
  "locationCustom": "",
  "radius": 0,
  "scrapeDetails": true,
  "maxItems": 50,
  "maxPagesPerSearch": 0,
  "startUrls": [],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "DE"
  },
  "requestDelay": 800,
  "maxConcurrency": 6
}
```

# Actor output Schema

## `jobId` (type: `string`):

StepStone job ID

## `title` (type: `string`):

Job title

## `url` (type: `string`):

Job posting URL

## `company` (type: `string`):

Hiring company

## `companyUrl` (type: `string`):

Company profile URL

## `companyProfileUrl` (type: `string`):

Company profile page

## `companyLogo` (type: `string`):

Company logo URL

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

Job location(s)

## `country` (type: `string`):

Country code

## `region` (type: `string`):

Region/state

## `locality` (type: `string`):

City

## `postalCode` (type: `string`):

Postal code

## `workFromHome` (type: `string`):

Home-office / remote info

## `contractType` (type: `string`):

Permanent / temporary etc.

## `workType` (type: `string`):

Full-time / part-time

## `employmentType` (type: `string`):

Schema.org employment type

## `industry` (type: `string`):

Industry / function

## `salary` (type: `string`):

Salary display (real or predicted)

## `salaryMin` (type: `string`):

Minimum salary amount

## `salaryMax` (type: `string`):

Maximum salary amount

## `salaryCurrency` (type: `string`):

Salary currency (ISO)

## `salaryPeriod` (type: `string`):

Salary period (Jahr/Monat/Stunde)

## `salaryPredicted` (type: `string`):

Salary is StepStone estimate

## `datePosted` (type: `string`):

ISO posting date

## `validThrough` (type: `string`):

ISO expiry date

## `postedRelative` (type: `string`):

e.g. 'vor 4 Tagen'

## `snippet` (type: `string`):

Search-result teaser

## `description` (type: `string`):

Full job description (text)

## `benefits` (type: `string`):

Benefits section

## `applyUrl` (type: `string`):

Application URL

## `directApply` (type: `string`):

Apply directly on StepStone

## `searchWhat` (type: `string`):

Keyword used

## `searchWhere` (type: `string`):

Location used

## `searchDomain` (type: `string`):

StepStone domain

## `rank` (type: `string`):

Position in results

## `scrapedAt` (type: `string`):

ISO scrape timestamp

# 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 = {
    "keyword": "software developer",
    "locationCustom": "",
    "maxItems": 50,
    "startUrls": [],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "DE"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("haketa/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 = {
    "keyword": "software developer",
    "locationCustom": "",
    "maxItems": 50,
    "startUrls": [],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "DE",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("haketa/stepstone-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "keyword": "software developer",
  "locationCustom": "",
  "maxItems": 50,
  "startUrls": [],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "DE"
  }
}' |
apify call haketa/stepstone-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,haketa/stepstone-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/dT9plb7TIYCqZeIVx/builds/J8hROGbV9970KbWGC/openapi.json