# StepStone Job Listing (`truefetch/stepstone-job-listing`) Actor

StepStone Job Listing provides StepStone job listings from Germany, Austria, Belgium, and the Netherlands with 41 normalized job, salary, company, application, and public contact fields.

- **URL**: https://apify.com/truefetch/stepstone-job-listing.md
- **Developed by:** [TrueFetch](https://apify.com/truefetch) (community)
- **Categories:** Jobs, Automation, Integrations
- **Stats:** 10 total users, 1 monthly users, 100.0% runs succeeded, 2 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $3.38 / 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?

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 Job Listing is a source for StepStone job listings from Germany, Austria, Belgium, and the Netherlands and returns 41 normalized job, salary, employer, application, and public contact fields, built for developers and data teams.**

- **4 supported European country sites.**
- **5 public inputs with 3 required.**
- **41 normalized Dataset fields.**
- **Country-wide or location-focused searches.**

[**Run a one-result test**](https://apify.com/truefetch/stepstone-job-listing) · [**View API**](https://apify.com/truefetch/stepstone-job-listing/api)

Set `max_results` to `1`; the smallest published-result test bills a minimum $0.01000 Actor Start plus one $0.00450 Result, or $0.01450 on FREE.

### What does StepStone Job Listing do?

StepStone Job Listing is a TrueFetch Apify Actor and StepStone jobs API for searching public vacancies on the German, Austrian, Belgian, and Dutch StepStone sites. Give it a keyword, select one supported country, and optionally name a city or region. The Actor opens the matching regional market, collects accessible listing details, and writes normalized records to the default Apify Dataset.

StepStone's [official FAQ](https://www.stepstone.de/e-recruiting/faq/frequently-asked-questions/) explains how keywords and classification affect whether job advertisements appear in search.

The output is intended for workflows that should not depend on four separate site layouts. One schema covers source links, job text, employment and work-mode signals, disclosed compensation, employer attributes, application destinations, and public company contact information when it can be found. Missing source data stays empty instead of being inferred.

This Actor is independent of StepStone and is not an official StepStone API. It does not log in, access applicant information, submit applications, or guarantee that every public vacancy will expose salary, work-mode, company, or contact details. Search supply and page availability can differ among the four regional sites.

### How do I run StepStone Job Listing?

1. Open [StepStone Job Listing on Apify](https://apify.com/truefetch/stepstone-job-listing).
2. Enter the required `keyword`, `country`, and `max_results` values.
3. Add a `location` only when the search should be narrower than the selected country.
4. Start with one result, examine its source and populated fields, and then raise the cap.

Every example below follows one scenario: retrieve one Supply Chain Manager vacancy around Vienna, Austria, and convert usable salary figures to EUR.

```json
{
  "keyword": "Supply Chain Manager",
  "country": "Austria",
  "max_results": 1,
  "location": "Vienna",
  "currency": "EUR"
}
```

`max_results` is a ceiling on jobs published by this run, not a promise that StepStone will expose that many matching and accessible vacancies. Omit `location` for a country-level request; the Actor does not silently replace the omission with a particular city.

### What data does StepStone Job Listing return?

The default Dataset schema contains **41 nullable fields**. A field is populated only when the source listing or subsequent public company enrichment supplies usable evidence.

| Field group | Fields |
| --- | --- |
| Processing | `processor`, `processed_at` |
| Source and application | `platform`, `platform_url`, `official_url`, `easy_apply` |
| Vacancy details | `title`, `description`, `job_type`, `job_level`, `job_function`, `listing_type`, `skills`, `experience_range` |
| Place and work mode | `location`, `is_remote`, `work_mode` |
| Timing and demand | `posted_date`, `valid_through`, `applicant_count`, `vacancy_count` |
| Compensation | `salary_minimum`, `salary_maximum`, `salary_currency`, `salary_period` |
| Employer | `company_name`, `company_type`, `company_founded`, `company_industry`, `company_url`, `company_website`, `company_logo`, `company_addresses`, `company_revenue`, `company_description`, `company_rating`, `employee_count`, `review_count` |
| Public contacts | `emails`, `phones`, `social_links` |

This shortened illustrative item uses the Vienna scenario; actual values depend on the live listing:

```json
{
  "platform": "StepStone",
  "platform_url": "https://www.stepstone.at/stellenangebote--example",
  "official_url": null,
  "title": "Supply Chain Manager",
  "company_name": "Example Logistics GmbH",
  "location": {
    "raw": "Wien",
    "locality": "Vienna",
    "country": "Austria",
    "country_code": "AT"
  },
  "job_type": "Full-time",
  "salary_currency": "EUR",
  "processor": "https://apify.com/truefetch/stepstone-job-listing",
  "processed_at": "2026-07-21T12:00:00.000Z"
}
```

Consult the live [Output schema](https://apify.com/truefetch/stepstone-job-listing/output-schema) for complete types and examples. Keep nullable fields nullable in downstream databases; an absent salary or external application URL is not a zero value.

### What inputs can I configure?

StepStone Job Listing exposes 5 public inputs in schema order, with 3 required and the rest optional.

| Parameter | Type | Required | Description | Example |
| --- | --- | :---: | --- | --- |
| `max_results` | integer | Yes | Maximum number of normalized StepStone listings to return. | `8` |
| `keyword` | string | Yes | Job title, skill, or company query for StepStone. | `Software Engineer` |
| `country` | select | Yes | Country for the StepStone regional search. | `Netherlands` |
| `location` | string | No | City, area, or postal code for StepStone. | — |
| `currency` | select | No | Target currency for converting salary amounts returned by StepStone. | — |

`country` has 4 accepted values; `currency` has 166 accepted values. Optional fields have no request effect when omitted; use the [live Input schema](https://apify.com/truefetch/stepstone-job-listing/input-schema) for types and accepted values.

### What platforms and markets does StepStone Job Listing cover?

StepStone Job Listing covers Germany, Austria, Belgium, and the Netherlands, one regional site per run.

The country selector contains 4 values: Austria, Belgium, Germany, Netherlands.

Coverage states where the Actor can form a request; live inventory, relevance, language, and optional field availability still come from the selected public source.

### Why use StepStone Job Listing?

| Capability | Workflow value |
| --- | --- |
| Regional domain selection | Send a search to the correct German, Austrian, Belgian, or Dutch site from one stable input contract. |
| Normalized European vacancy records | Store comparable fields even when source pages use different languages or layouts. |
| Country-wide and local modes | Build national snapshots or city-level watchlists without an imposed city default. |
| Salary conversion option | Standardize disclosed numeric pay for cross-market analysis while retaining source availability limits. |
| Source traceability | Keep the StepStone listing URL and a separate employer application URL when one is exposed. |
| Apify operation | Run through Console, schedules, webhooks, API clients, or an MCP-enabled assistant. |

The practical trade-off is source variability. Normalization makes records easier to consume, but it cannot make sparse public listings complete or turn a result cap into guaranteed inventory.

### Who is StepStone Job Listing for?

| User | Example outcome |
| --- | --- |
| European recruiting teams | Monitor named roles by country or hiring city. |
| Labor-market researchers | Compare vacancy supply across selected DACH and Benelux markets. |
| Compensation analysts | Review disclosed salary bands and convert usable figures to a common currency. |
| Job-product developers | Add source-attributed StepStone records to a search or alert feature. |
| Employer-intelligence teams | Track public hiring activity and available company context over time. |

It is not a candidate database, resume scraper, application bot, or substitute for legal review. Apply appropriate retention, attribution, and regional data-handling policies to the results you store.

### How can I use StepStone Job Listing through the API or MCP?

The public Actor ID is **`Idw1RmE8raKFIgRPf`**; the name form **`truefetch/stepstone-job-listing`** is also accepted. This synchronous request runs the same one-result Vienna scenario and returns Dataset items in the response:

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/Idw1RmE8raKFIgRPf/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "keyword": "Supply Chain Manager",
    "country": "Austria",
    "max_results": 1,
    "location": "Vienna",
    "currency": "EUR"
  }'
```

For MCP, use Apify's Streamable HTTP endpoint and limit the exposed tools to this Actor:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com/?tools=truefetch/stepstone-job-listing",
      "headers": {
        "Authorization": "Bearer <APIFY_TOKEN>"
      }
    }
  }
}
```

Then ask the connected client to run the same Vienna input. The [API page](https://apify.com/truefetch/stepstone-job-listing/api) also shows asynchronous endpoints, SDK examples, and OpenAPI details. Keep tokens in secrets or environment variables, never in committed files.

### How much does StepStone Job Listing cost?

StepStone Job Listing costs $0.00450 per Result on FREE plus $0.01000 per minimum Actor Start event, so the smallest one-result test totals $0.01450.

| Apify tier | Actor Start | Per Result |
| --- | ---: | ---: |
| FREE | $0.01000 | $0.00450 |
| BRONZE | $0.01000 | $0.00405 |
| SILVER | $0.01000 | $0.00360 |
| GOLD | $0.01000 | $0.00338 |
| PLATINUM | $0.01000 | $0.00338 |
| DIAMOND | $0.01000 | $0.00338 |

Result is billed once for each item written to the default Dataset. Actor Start event count depends on selected memory, with a minimum of one event.

Smallest useful test: $0.01000 + 1 × $0.00450 = **$0.01450** on FREE when one item is published. A zero-result run can still incur Actor Start. [Prices can change; check live pricing](https://apify.com/truefetch/stepstone-job-listing/pricing) before scheduling volume.

### How does StepStone Job Listing compare with alternatives?

| Decision | StepStone Job Listing | Multi-board Job Search | Manual regional browsing |
| --- | --- | --- | --- |
| Source scope | Four specified StepStone sites | Multiple compatible job boards | Whichever site a person opens |
| Data shape | One 41-field Dataset | Shared cross-source schema | Pages and copied notes |
| Repeatability | Saved input, API, MCP, and schedules | Similar automation with broader sources | Manual repetition |
| Strongest fit | StepStone-specific DACH/Benelux monitoring | Broader source discovery | Occasional individual review |
| Main constraint | Five-input search contract and variable public fields | Less source-specific focus | No dependable structured export |

Choose this Actor when StepStone attribution and its four supported European markets matter. Choose [Job Search](https://apify.com/truefetch/job-search) when one request should cover several job boards. Manual review remains appropriate for a small number of final candidate listings or application decisions.

### What are the limits and troubleshooting steps?

| Symptom or limit | Likely reason | Safe next step |
| --- | --- | --- |
| Fewer jobs than `max_results` | The cap exceeds live, relevant, accessible inventory. | Broaden the keyword or omit the location. |
| No result for a city | The local spelling or source inventory may differ. | Try the regional spelling, then test the country without `location`. |
| The wrong regional language appears | Listing text comes from the selected country site and publisher. | Use `country` as the authoritative market selector. |
| Salary fields are empty | Many vacancies do not disclose numeric pay. | Treat salary columns as nullable and compare only populated records. |
| Converted salary is absent | Conversion needs usable source amount, currency, and exchange-rate data. | Inspect the original salary fields and source page. |
| `official_url` is null | The page may not expose a separate external application destination. | Retain `platform_url` as the source record. |
| A repeated run changes | Listings close, update, move, or become inaccessible. | Store timestamps and compare runs as snapshots, not static truth. |

For a reproducible support case, use one country, a simple keyword, and `max_results: 1`. Share the Apify run URL through [Issues](https://apify.com/truefetch/stepstone-job-listing/issues), but never include your token.

### Frequently asked questions

#### How do I get stepstone job listings by keyword?

Set `keyword`, `country`, and `max_results`, then add only the optional fields present in this Actor's input table. Results are capped by source availability and relevance.

#### What does “stepstone jobs api without login” mean for this Actor?

The Actor runs on Apify without asking for a source-site publisher credential; an Apify account and token are still required for authenticated API or MCP calls.

#### Does StepStone Job Listing require a source-site login?

No source-site username, password, cookie, or API key appears in the public input. The Actor collects accessible public listings independently of the source.

#### Why are salary, company, applicant, or contact values empty?

Those values are nullable because public listings do not expose the same detail. Empty means unavailable from the collected source, not zero or false.

#### Is there a free jobs API?

Apify accounts include platform usage under the current Apify plan, while this Actor bills Actor Start and Result events. Use the one-result calculation in Pricing to evaluate the smallest test.

#### Can I schedule runs to monitor StepStone vacancies over time?

Yes. Test a small input first, then use Apify schedules and webhooks. Preserve `processed_at` and source URLs because listings can change, close, or reappear.

#### How is billing counted for StepStone Job Listing?

Billing uses Actor Start events and one Result event per default Dataset item. A requested result limit is a cap, not a prepaid bundle or a guarantee of source inventory.

### Related TrueFetch Actors

StepStone Job Listing has three nearby TrueFetch alternatives, each for a different source decision.

- [Job Search](https://apify.com/truefetch/job-search) — Use it when several compatible boards are needed.
- [Indeed Job Listing](https://apify.com/truefetch/indeed-job-listing) — Use it for broader Indeed market coverage and filters.
- [LinkedIn Job Listing](https://apify.com/truefetch/linkedin-job-listing) — Use it for LinkedIn recency and employment filters.

### Support

Use the [Store page](https://apify.com/truefetch/stepstone-job-listing) for the run interface, the [API page](https://apify.com/truefetch/stepstone-job-listing/api) for generated clients, [Issues](https://apify.com/truefetch/stepstone-job-listing/issues) for reproducible bugs, and the [TrueFetch community](https://t.me/TrueFetch) for usage questions.

[**Run a one-result test**](https://apify.com/truefetch/stepstone-job-listing) · [**View API**](https://apify.com/truefetch/stepstone-job-listing/api)

**Last Updated:** August 10, 2026

# Actor input Schema

## `max_results` (type: `integer`):

Maximum StepStone job rows to return

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

Job title, skill, or company query to search on StepStone

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

Country-specific StepStone market used for the search

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

Optional city, area, or postal code for the StepStone search

## `currency` (type: `string`):

Optional target currency for normalized StepStone salary amounts

## Actor input object example

```json
{
  "max_results": 8,
  "keyword": "Software Engineer",
  "country": "Netherlands"
}
```

# Actor output Schema

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

Default dataset overview of normalized job listings and company fields collected by All Jobs Scraper.

# 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 = {
    "max_results": 8,
    "keyword": "Software Engineer",
    "country": "Netherlands"
};

// Run the Actor and wait for it to finish
const run = await client.actor("truefetch/stepstone-job-listing").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 = {
    "max_results": 8,
    "keyword": "Software Engineer",
    "country": "Netherlands",
}

# Run the Actor and wait for it to finish
run = client.actor("truefetch/stepstone-job-listing").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 '{
  "max_results": 8,
  "keyword": "Software Engineer",
  "country": "Netherlands"
}' |
apify call truefetch/stepstone-job-listing --silent --output-dataset

```

## MCP server setup

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

```

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/Idw1RmE8raKFIgRPf/builds/N8mbArz9dDouaHQiG/openapi.json