# StepStone Jobs Scraper - Germany, Austria & Belgium (`thirdwatch/stepstone-jobs-scraper`) Actor

Scrape StepStone jobs in Germany, Austria, and Belgium over HTTP. Get full descriptions, salary, employer, location, remote mode, skills, dates, filters, and apply URLs without a browser.

- **URL**: https://apify.com/thirdwatch/stepstone-jobs-scraper.md
- **Developed by:** [Thirdwatch](https://apify.com/thirdwatch) (community)
- **Categories:** Jobs, Lead generation
- **Stats:** 10 total users, 5 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.55 / 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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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 Jobs Scraper — Germany, Austria & Belgium

Turn StepStone searches into clean job-market data without a browser, login, or manual pagination. Search by role and location or paste an existing StepStone result page. The Actor returns one normalized row per job across `stepstone.de`, `stepstone.at`, and `stepstone.be`.

It is built for recurring recruiting feeds, salary research, hiring-intent signals, and European job-board products—not just one-off exports.

### Why use this StepStone scraper?

- **Three markets, one schema:** Germany, Austria, and Belgium produce the same columns.
- **Full job details:** complete descriptions, employment type, industry, structured address, expiry date, employer, and apply flow.
- **Useful search controls:** newest-first sorting, posted-within filters, home-office mode, and direct-apply jobs.
- **Up to 1,000 jobs per query:** pagination is automatic and duplicate job IDs are removed across inputs.
- **Browserless HTTP:** direct structured data plus a lightweight TLS client keeps runs fast and inexpensive.
- **Pay only for results:** empty searches and failed requests create no paid dataset items.

At the Gold tier, the result price is **$0.55 per 1,000 jobs**. That is designed for scheduled feeds and bulk market research, not tiny demo-only runs.

### Input

Use keyword searches, existing URLs, or both.

```json
{
  "country": "de",
  "queries": ["software engineer", "data scientist"],
  "location": "Berlin",
  "maxResultsPerQuery": 100,
  "sortBy": "date",
  "postedWithinDays": 7,
  "workFromHome": "any",
  "directApplyOnly": false,
  "includeDetails": true,
  "includeDescription": true,
  "cleanHtml": true,
  "maxConcurrency": 5
}
```

You can also paste filtered search pages or individual jobs:

```json
{
  "startUrls": [
    {"url": "https://www.stepstone.de/jobs/data-engineer/in-muenchen?sort=2"},
    {"url": "https://www.stepstone.at/jobs/software-engineer/in-wien"}
  ],
  "maxResultsPerQuery": 250
}
```

Filters already present in a Start URL are preserved. Explicit Actor inputs add or override their matching URL parameters.

### Output fields

Every country uses the same stable schema. Search-only mode returns the first group immediately; detail mode adds the richer fields.

| Group | Fields |
|---|---|
| Identity | `job_id`, `title`, `job_url`, `source_market`, `source_search_url` |
| Employer | `company_id`, `company_name`, `company_url`, `company_logo_url` |
| Location | `location`, `postal_code`, `address_street`, `address_locality`, `address_region`, `address_country` |
| Salary | `salary_raw`, `salary_min`, `salary_max`, `salary_currency`, `salary_period`, `salary_available` |
| Job attributes | `employment_type`, `industry`, `skills`, `work_from_home`, `labels`, `direct_apply` |
| Dates | `date_posted`, `valid_through`, `scraped_at` |
| Content | `snippet`, `description`, `description_html` |
| Ranking context | `section`, `is_sponsored`, `is_top_job` |
| Application | `apply_url` when StepStone hosts the direct application flow |

Example result:

```json
{
  "job_id": "14138674",
  "title": "Software Engineer (ServiceNow) - RegTech",
  "company_name": "N26 GmbH",
  "location": "Berlin, de",
  "work_from_home": "hybrid",
  "date_posted": "2026-07-11T01:31:28.927Z",
  "valid_through": "2026-08-10T01:31:28.927Z",
  "employment_type": "FULL_TIME",
  "industry": "IT, IT-Softwareentwicklung",
  "direct_apply": true,
  "description": "About the opportunity ...",
  "job_url": "https://www.stepstone.de/stellenangebote--...--14138674-inline.html",
  "apply_url": "https://www.stepstone.de/stellenangebote--...--14138674-inline.html",
  "source_market": "de"
}
```

### Common workflows

#### Monitor new jobs by role and city

Set `sortBy` to `date`, `postedWithinDays` to `1` or `7`, and schedule the Task daily. Stable `job_id` values make downstream deduplication straightforward.

#### Build salary benchmarks

Run several role/location pairs with `includeDetails: false`. The search payload already includes StepStone's published salary range and currency when available, so this is the cheapest mode.

#### Find companies actively hiring

Aggregate by `company_name` and `company_id`, then join the employer URL into a recruiting, sales, or market-intelligence workflow. The Actor returns public job and employer information; it does not invent personal contact data.

#### Feed a job board or ATS

Keep `includeDetails` enabled for full descriptions and expiry dates. Use `source_market` to partition Germany, Austria, and Belgium while retaining one schema.

### Cost and speed controls

- Disable `includeDetails` for the lowest-cost monitoring and salary-analysis runs.
- Disable `includeDescription` when descriptions are not needed downstream.
- Keep `maxConcurrency` between 3 and 5 for balanced throughput and reliability.
- Use focused queries and recent-date filters instead of downloading thousands of irrelevant rows.

### Reliability behavior

Search pages use StepStone's server-rendered state and automatically fall back to a German/Austrian/Belgian residential route when the direct HTTP lane is blocked. Detail pages use structured `JobPosting` data. If one detail request fails, the Actor preserves the useful search row instead of discarding the job. If every input fails, the run fails explicitly rather than reporting a misleading successful run with zero results.

### FAQ

#### Does it need a StepStone account or cookies?

No. It reads publicly accessible job searches and job pages.

#### Can I scrape a filtered StepStone URL?

Yes. Paste it into `startUrls`; the Actor preserves its query-string filters and paginates the result set.

#### Does it return external ATS application URLs?

`apply_url` is set when StepStone declares a direct application flow. For externally hosted applications, the destination may only be resolved after an interactive click, so the Actor returns the public `job_url` and leaves `apply_url` empty rather than guessing.

#### Are descriptions plain text or HTML?

Both modes are supported. `cleanHtml: true` returns readable text in `description`; turn it off to retain the source HTML.

#### Is this affiliated with StepStone?

No. This independent Actor extracts publicly available information. Use the data in accordance with StepStone's terms and applicable privacy, employment, and database laws.

### Support

Open an issue on the Actor page with a reproducible public URL and the missing or incorrect field. We prioritize broken searches and schema regressions.

**SEO keywords:** StepStone scraper, StepStone jobs API, StepStone Germany scraper, StepStone Austria jobs, StepStone Belgium jobs, German job listings API, salary data scraper, recruiting data, job market intelligence, StepStone job monitoring.

# Actor input Schema

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

Choose the StepStone country site used for keyword searches. Start URLs can mix supported markets.

## `queries` (type: `array`):

One search per value, for example software engineer or data scientist.

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

City or region applied to keyword searches, for example Berlin, Wien, or Brussels.

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

Optional StepStone result pages or individual job URLs. Existing URL filters and country domains are preserved.

## `maxResultsPerQuery` (type: `integer`):

Each query or search URL can return up to this many unique jobs.

## `sortBy` (type: `string`):

Order each search by StepStone relevance or newest posting date.

## `postedWithinDays` (type: `string`):

Keep jobs posted within this many days. Use 0 for any date.

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

Limit results to partly remote or fully remote jobs, or keep every work mode.

## `directApplyOnly` (type: `boolean`):

Only return listings where StepStone hosts the application flow.

## `includeDetails` (type: `boolean`):

Adds the complete description, employment type, industry, valid-through date, and structured address.

## `includeDescription` (type: `boolean`):

Include the complete public job description when detail enrichment is enabled.

## `cleanHtml` (type: `boolean`):

Return description as readable text instead of HTML.

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

Number of detail pages fetched concurrently. Lower this if the source becomes unstable.

## Actor input object example

```json
{
  "country": "de",
  "queries": [
    "software engineer",
    "data scientist"
  ],
  "location": "Berlin",
  "startUrls": [],
  "maxResultsPerQuery": 100,
  "sortBy": "relevance",
  "postedWithinDays": "0",
  "workFromHome": "any",
  "directApplyOnly": false,
  "includeDetails": true,
  "includeDescription": true,
  "cleanHtml": true,
  "maxConcurrency": 5
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "queries": [
        "software engineer",
        "data scientist"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("thirdwatch/stepstone-jobs-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 = { "queries": [
        "software engineer",
        "data scientist",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("thirdwatch/stepstone-jobs-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 '{
  "queries": [
    "software engineer",
    "data scientist"
  ]
}' |
apify call thirdwatch/stepstone-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/bYhTccjIKDPgPvwTi/builds/9T7zy8UIOAnLx12et/openapi.json