# StepStone Jobs Scraper & New Job Monitor - DE, AT, BE, NL (`neverempty/stepstone-jobs-scraper`) Actor

For recruiters, job alerts and hiring lead lists: StepStone jobs on stepstone.de, .at, .be and .nl by keyword and city, with company, location, date, remote or hybrid and link; job details optional. StepStone re-dates old ads (7 of the top 25 on 2026-09-25); monitor mode returns only new jobs.

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

## Pricing

from $1.75 / 1,000 job returneds

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 & New Job Monitor - DE, AT, BE, NL

Get **StepStone jobs** as clean JSON from **stepstone.de, stepstone.at, stepstone.be and stepstone.nl**: job title, **company**, location, date posted, **remote work (hybrid or fully remote)**, easy apply, and the link. Search by **job title or keyword** and **city**, or paste StepStone search URLs. Turn on **Monitor mode** and scheduled runs return **only jobs that are new since the last check** - so a recruiter, a job alert, a Slack or Telegram bot or a lead list gets the new ones without paying for the same jobs again. Turn on **job page details** to add **employment type** (full-time, part-time ...), the **application deadline**, the industry and the **full description**.

- **New job monitor that does not sell old ads as new.** StepStone re-dates older ads to today. In our check on 2026-09-25, 7 of the top 25 Pflegefachkraft jobs in Germany were ads with old StepStone IDs (for example 10973152) dated that night. Monitor mode tells them apart with StepStone's job IDs (they grow with every new ad) and the date: `changeType: new` is only for a job dated after the last check whose ID is higher than every job this watch has seen. Re-dated old ads can be returned separately as `reposted`.
- **Only the jobs you searched for.** When a search has few matches, StepStone fills the page with similar job titles and recommendations. On 2026-09-25, `python` on stepstone.nl showed 1 match and 24 recommendations, and `data scientist` in München showed 18 matches and 7 similar jobs (Data Platform Architect, Business Data Analyst ...). By default this Actor returns only the matches and jobs in nearby places, and says which is which in `matchType`.
- **Salary only when it is there, and where it comes from.** StepStone puts a salary on the search page only sometimes, and then it is usually StepStone's own estimate, not a number from the employer: in our production runs on 2026-09-25, 0 of 109 jobs had one; in one of our checks StepStone's estimates came for 22 of 25 jobs. `salarySource` says `stepstone-estimate` or `posted` (stated in the ad, read from the job page with `includeJobDetails`). Nothing is made up.
- **Remote work filter.** `remoteWork`: hybrid or fully remote, or fully remote only.
- **Four countries in one run.** stepstone.de, .at, .be and .nl: keywords times locations times sites, plus search URLs, up to 20 searches per run.
- **Honest about what can be read.** StepStone's robots.txt does not allow page numbers or filters in the URL, so this Actor reads the first page of each search: 25 jobs, most relevant first. When a search has more, a free row says so.
- **No charge when nothing could be delivered.** A search with no jobs, nothing that passes your filters, a page that could not be read, and a check page come back as free rows that say why.

Unofficial. Reads the public StepStone search result pages (and, if you turn it on, the public job pages), the same pages a person sees without logging in, and follows StepStone's robots.txt. It does not log in, does not apply to jobs, and does not solve or bypass check pages. It returns **the company, not the people**: there are no recruiter or contact person columns. Contact sections of job descriptions are left out, and in the remaining text phone numbers, e-mail addresses and names are replaced with `[phone removed]`, `[email removed]`, `[name removed]`: names after a title (Frau, Herr, Mr, Ms, Mevrouw, Madame ...) or a label (Ansprechpartner, Kontakt, Contact ...), names before a recruiting job title (Personalreferentin, Recruiter, HR Manager, Talent Acquisition ...) and names right before an e-mail address or phone number. A name written anywhere else in free text is not recognised (see Limits). Companies that post anonymously stay anonymous (`company: null`, `companyAnonymous: true`).

### What you get

One row per job. Example (a production run on 2026-09-25, `Data Scientist` in `München` with job page details; `description` and `snippet` are shortened here):

```json
{
  "status": "ok",
  "changeType": null,
  "jobId": "14532604",
  "title": "Data Scientist (w/m/d)",
  "company": "TÜV SÜD",
  "companyAnonymous": false,
  "companyId": "54474",
  "companyUrl": "https://www.stepstone.de/cmp/de/t%c3%9cv-s%c3%9cd-54474/jobs",
  "companyLogoUrl": "https://www.stepstone.de/upload_DE/logo/B/logoTUV-SUD-54474DE-2305081235.gif",
  "location": "München",
  "locations": [
    "München"
  ],
  "postalCode": "80686",
  "country": "de",
  "datePosted": "2026-09-22T23:51:45.000Z",
  "datePostedLocal": "2026-09-23T01:51:45+02:00",
  "remoteWork": "hybrid",
  "employmentType": [
    "full-time"
  ],
  "salaryMin": null,
  "salaryMax": null,
  "salaryCurrency": null,
  "salaryPeriod": null,
  "salarySource": null,
  "validThrough": "2026-11-22T06:51:31.037Z",
  "industry": "Wissenschaften, Wissenschaften-Data Science",
  "description": "Einleitung Bei der TÜV SÜD Gruppe leben wir unsere Leidenschaft für Technik. Innovationen beeinflussen unser Leben in vielfältiger Weise. Bei der TÜV SÜD Gruppe sind wir in hohem Maße bestrebt, ein wichtiger Teil dieses Fortschritts zu sein. Wir ...",
  "snippet": "Bei der TÜV SÜD Gruppe leben wir unsere Leidenschaft für Technik. Innovationen beeinflussen unser Leben in vielfältiger Weise. Bei der TÜV SÜD Gruppe sind wir in hohem Maße ...",
  "benefits": null,
  "skills": [],
  "easyApply": false,
  "noCoverLetter": false,
  "isPromoted": false,
  "matchType": "exact",
  "sourceSite": null,
  "latitude": 48.143295,
  "longitude": 11.564068,
  "detailsStatus": "ok",
  "url": "https://www.stepstone.de/stellenangebote--Data-Scientist-w-m-d-Muenchen-TUEV-SUED--14532604-inline.html",
  "positionInSearch": 1,
  "jobsInSearch": 24,
  "searchQuery": "Data Scientist",
  "searchLocation": "München",
  "searchCountry": "de",
  "searchUrl": "https://www.stepstone.de/jobs/data-scientist/in-m%C3%BCnchen",
  "watchName": null,
  "checkedAt": "2026-09-24T23:45:16.822Z"
}
```

Checked in a browser after the runs: 5 of 5 jobs from that run showed the same title, company and place on the StepStone job page, and the job page of the example says "Feste Anstellung", "Homeoffice möglich, Vollzeit" (`employmentType: full-time`, `remoteWork: hybrid`).

| Column | Meaning |
|---|---|
| `status` | `ok` for a job row. Other values are free rows that say why nothing (or not everything) was returned (below) |
| `changeType` | Monitor mode only: `first-check` (first run of this watch), `new`, or `reposted` (only with `includeReposted`). Null when monitor mode is off |
| `jobId`, `url` | StepStone's job ID and the job page |
| `title` | Job title |
| `company`, `companyId`, `companyUrl`, `companyLogoUrl` | The employer as shown on StepStone. Null (and `companyAnonymous: true`) when the ad is anonymous |
| `location`, `locations`, `postalCode` | Location text as shown, the same split into places, and the postal code when StepStone gives one |
| `country` | `de`, `at`, `be` or `nl` (the StepStone site) |
| `datePosted`, `datePostedLocal` | The date on the job as UTC and as shown by StepStone with its time zone. StepStone re-dates some older ads; see `changeType` |
| `remoteWork` | `fully-remote` (home office only), `hybrid` (partly home office), or null when the ad does not say |
| `salaryMin`, `salaryMax`, `salaryCurrency`, `salaryPeriod`, `salarySource` | Salary range, only when StepStone shows one (often it does not). `salarySource` is `stepstone-estimate` (StepStone's estimate on the search page) or `posted` (stated in the ad, from the job page). Null when there is none; nothing is made up |
| `employmentType`, `validThrough`, `industry`, `description`, `latitude`, `longitude` | With `includeJobDetails` only: employment type (`full-time`, `part-time` ...), application deadline, industry, full description (contacts removed), and coordinates when the job page has them |
| `detailsStatus` | With `includeJobDetails`: `ok`, `gone` (the job page no longer exists), `unreadable`, `blocked` or `not-allowed-by-robots-txt` |
| `snippet`, `benefits` | The short description and benefits shown on the search result (contacts removed) |
| `skills` | Skills StepStone lists for the job, when it shows them |
| `easyApply`, `noCoverLetter` | StepStone's "Schnelle Bewerbung" (quick apply) and "Anschreiben nicht erforderlich" (no cover letter) labels |
| `isPromoted` | The job is a paid top or highlighted ad |
| `matchType` | `exact` (matches your search), `nearby` (in a place near your location), `related` or `recommended` (only with `includeRelatedJobs`) |
| `sourceSite` | Partner site the ad comes from, when StepStone shows one |
| `positionInSearch`, `jobsInSearch` | Position on the first page, and the number of matching jobs StepStone reports (matches plus nearby) |
| `searchQuery`, `searchLocation`, `searchCountry`, `searchUrl` | The search this row came from |
| `note` | Free rows only: why nothing (or not everything) was returned |
| `watchName`, `checkedAt` | The watch name you gave, and the time of the check |

#### Free rows (not charged)

| `status` | When |
|---|---|
| `no-results` | StepStone has no job for this search (also what StepStone answers for a place it does not know) |
| `none-match-filters` | Jobs were read, but none passes your filters (remote work, posted within, matches only) |
| `not-found` | StepStone does not have this page (HTTP 404), or sent the search to a page robots.txt does not allow |
| `no-new-jobs` | Monitor mode: nothing new since the previous check |
| `more-not-returned` | Normal search: the search has more jobs than the first page, which is all robots.txt allows; says how many and what to do. Monitor mode: more new jobs than `maxResultsPerSearch` (a later run returns them), or, on the first check, how many jobs are now the starting point and that only the first page is watched |
| `more-new-than-readable` | Monitor mode: jobs an earlier run could not return (because of `maxResultsPerSearch` or the charge limit) left the first page before they could be returned |
| `already-returned` | Everything on this search was already returned by an earlier search of the same run; it is not returned or charged twice |
| `not-allowed-by-robots-txt` | A search StepStone's robots.txt does not allow: a URL with a page number or a filter (`?page=`, `?radius=`, `?sort=` ...), or a keyword that points to a disallowed page (`vollzeit`, `teilzeit`, `home-office` on stepstone.de, `full-time`, `work-from-home` on stepstone.be and .nl). Nothing was requested |
| `unreadable` | StepStone could not be read, even after asking again from other IP addresses, or the page layout changed. Nothing is guessed and nothing is remembered |
| `blocked` | StepStone showed a check page. This Actor does not solve or bypass check pages; it stops and does not run the remaining searches (if it happened on a job page, the jobs already read from that search are returned, without job page details from that point on, `detailsStatus: blocked`) |
| `budget-reached` | The run hit the maximum total charge you set. In monitor mode the jobs not returned are returned by the next run |
| `bad-input` | The input could not be used (for example an unknown site). The run ends as failed |

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `searchQueries` | list of strings | - | Job titles or keywords: `Data Scientist`, `Pflegefachkraft`, `Python`, `Buchhalter`, `SAP` ... Leave keywords, locations and search URLs all empty to run the example: `Data Scientist` in `Berlin` on stepstone.de |
| `locations` | list of strings | whole country | Cities or regions as StepStone writes them: `Berlin`, `München`, `Frankfurt am Main`, `Wien`, `Brussels`, `Amsterdam` |
| `countries` | list of `de`, `at`, `be`, `nl` | `de` | StepStone sites to search |
| `searchUrls` | list of strings | - | StepStone search result pages copied from the browser, for example `https://www.stepstone.de/jobs/data-scientist/in-berlin` (the plain first page, without filters in the URL) |
| `remoteWork` | `any`, `hybrid-or-remote`, `fully-remote` | `any` | Remote work filter, applied to the jobs on the first page |
| `postedWithinDays` | integer 1-60 | - | Only jobs posted within this many days, applied to the jobs on the first page |
| `includeRelatedJobs` | boolean | false | Also return StepStone's similar-title and recommended jobs, marked in `matchType` |
| `includeJobDetails` | boolean | false | Also read each returned job's page: employment type, deadline, industry, full description, posted salary, coordinates |
| `maxResultsPerSearch` | integer 1-25 | 25 | Most jobs returned for one search. In monitor mode: most new jobs per search in one run (the rest come first in the next run, while they are still on the first page) |
| `onlyNew` | boolean | false | Monitor mode: return only jobs that are new since the previous check |
| `includeReposted` | boolean | false | Monitor mode: also return ads dated after the previous check whose ID is lower than the newest ID this watch has seen (re-dated older ads, rarely an ad StepStone published late), as `reposted` |
| `watchName` | string | - | Separate memories for monitor mode, for example one per client or per alert |
| `resetMonitoringState` | boolean | false | Forget what this watch has seen, so the run is a first check again |

Each keyword is searched in each location on each site (up to 20 searches per run). A keyword alone searches the whole country; a location alone lists all jobs there.

### Examples

Data scientists in Munich and Berlin, hybrid or remote, with employment type and full description:

```json
{ "searchQueries": ["Data Scientist"], "locations": ["München", "Berlin"], "remoteWork": "hybrid-or-remote", "includeJobDetails": true }
```

A daily job alert: new Python jobs in Vienna and Brussels and data engineer jobs in the Netherlands (schedule this input):

```json
{ "searchUrls": ["https://www.stepstone.at/jobs/python/in-wien", "https://www.stepstone.be/jobs/python/in-brussels", "https://www.stepstone.nl/vacatures/data-engineer"], "onlyNew": true, "watchName": "python-data-benelux-at" }
```

Nursing jobs posted in the last 3 days in Hamburg:

```json
{ "searchQueries": ["Pflegefachkraft"], "locations": ["Hamburg"], "postedWithinDays": 3 }
```

### Pricing

Pay per event:

- **Run start** - once per run that read StepStone: in a normal search, before the first job row is returned (so not charged when nothing passes your filters); in monitor mode, when a list was read and compared, also when nothing is new - that pays for the check. Never charged when nothing could be read or robots.txt does not allow the page.
- **Job returned** - per job row.
- **Job with details** - per job row with job page details (`includeJobDetails`), instead of Job returned. A row whose job page could not be read is charged as Job returned.

Free rows are never charged. If you set a maximum total charge for a run, the run stops before it would go over it and says so; a run whose maximum has no room for the start fee plus one job does not request anything, and job pages are only read for rows that fit.

### Monitor mode, step by step

1. First run: reads the first page of each search, returns up to `maxResultsPerSearch` as `first-check`, and remembers the jobs as the starting point.
2. Later runs: read the first page again. A job this watch has not seen is `new` when it is dated after the previous check (with 3 hours of slack for StepStone's indexing) and its StepStone job ID is higher than every job ID this watch has seen (IDs grow with every new ad). A job dated after the previous check with a lower ID is a re-dated older ad: remembered, and returned only with `includeReposted` (as `reposted`). An older job that moved up into the first page is remembered but not returned. Jobs that were not returned because of `maxResultsPerSearch` or the charge limit are returned first by the next run, as long as they are still on the first page.
3. Nothing is judged from a page that could not be read (nothing returned, remembered or charged); the next run checks it again.

Within one run, a job found by two overlapping searches is returned once.

Keep one schedule per search and watch name. Two overlapping runs of the same watch can both return the same new job (the memory is a key-value store without transactions).

### Limits

- StepStone's robots.txt does not allow page numbers, sorting or filters in the URL, so only the first page of each search is read: **25 jobs, most relevant first** (not newest first). A new job that StepStone ranks lower is not seen by monitor mode. Narrow broad searches (a city, a more exact job title) and split one big search into several smaller ones in the same run.
- The radius and StepStone's own filters (full-time, part-time, date posted, remote) cannot be put in the URL; `remoteWork` and `postedWithinDays` are applied to the jobs read from the first page.
- Salaries are often missing: StepStone shows its estimate on the search page only sometimes, and a salary stated in the ad is only read with `includeJobDetails` (and only when the ad's job page lists it).
- Names in job descriptions are recognised only next to a title, a label, a recruiting job title or an e-mail address or phone number (see above); other names in free text are not. In 10 production job pages on 2026-09-25 two recruiter names appeared in such places and both are removed now. Contact sections, phone numbers and e-mail addresses are removed.
- Monitor mode counts a job as new only when its ID is higher than every ID the watch has seen. An ad StepStone publishes late with an older ID (for example a scheduled ad) comes back as `reposted` (with `includeReposted`) instead of `new`.
- If StepStone refuses datacenter IP addresses, pages are read over residential IP addresses in the site's country: up to 20 search pages and 60 job pages per run, and up to 2 search pages per monitor run. stepstone.at refused residential IP addresses in our checks on 2026-09-25; it is read from Apify's own IP addresses.

### Support

Questions, a field you need, or a search that does not work: open an issue on the Issues tab of this Actor.

# Actor input Schema

## `searchQueries` (type: `array`):

What you would type into the StepStone "What" box, for example Data Scientist, Pflegefachkraft, Python, Buchhalter, SAP. Each keyword is searched in each location and country. Leave Job titles, Locations and Search URLs all empty to run the example search: Data Scientist in Berlin on stepstone.de.

## `locations` (type: `array`):

Optional. City or region as StepStone writes it, for example Berlin, München, Frankfurt am Main, Hamburg, Wien, Graz, Brussels, Antwerpen, Amsterdam. Empty = the whole country. StepStone answers an unknown place with 0 jobs (a free row says so).

## `countries` (type: `array`):

Which StepStone sites to search: stepstone.de (default), stepstone.at, stepstone.be, stepstone.nl. Every keyword and location is searched on every site you pick.

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

Optional. StepStone search result pages copied from your browser, for example https://www.stepstone.de/jobs/data-scientist/in-berlin or https://www.stepstone.nl/vacatures/python. Paste the plain first page: StepStone's robots.txt does not allow page numbers or filters in the URL (?page=, ?radius=, ?sort=, ?wfh= ...), so such URLs come back as a free row. Use the filters below instead.

## `remoteWork` (type: `string`):

Any (default), jobs StepStone marks as partly home office (hybrid) or home office only, or home office only. Applied to the jobs read from the first page of each search.

## `postedWithinDays` (type: `integer`):

Optional. Only jobs StepStone shows as posted within this many days. Applied to the jobs read from the first page of each search.

## `includeRelatedJobs` (type: `boolean`):

Off (default): only jobs that match your search (matchType exact) and jobs in nearby places (matchType nearby). StepStone fills the rest of a short result page with similar job titles and recommendations (for python on stepstone.nl: 1 match and 24 recommendations). On: return those too, marked matchType related or recommended.

## `includeJobDetails` (type: `boolean`):

On: for each job returned, also read its job page and add employmentType (full-time, part-time ...), validThrough (deadline), industry, the full description (contact names, phone numbers and e-mails removed), postal code and coordinates, and the posted salary if the ad states one. Rows with job page details are charged as job-with-details instead of job-returned. If a job page cannot be read, the row is still returned as job-returned with detailsStatus saying why.

## `maxResultsPerSearch` (type: `integer`):

Most jobs returned for one search. StepStone's robots.txt allows only the first page of a search (25 jobs, most relevant first), so 25 is the maximum and the default. In monitor mode it limits the new jobs returned per search in one run; the rest come first in the next run, while they are still on the first page.

## `onlyNew` (type: `boolean`):

On: every run reads the first page of each search and returns only jobs that are new since the previous check (changeType new). Old jobs that StepStone re-dated to today (reposted) and older jobs that moved up into the first page are not sold as new. The first run returns the current jobs (changeType first-check) and remembers them as the starting point. Each run that reads the list is charged the run start fee even when nothing is new; such runs return a free row saying so.

## `includeReposted` (type: `boolean`):

Off (default): a job this watch had not seen, dated after the previous check but with a lower StepStone ID than the newest job this watch has seen (an older ad re-dated to today, rarely an ad StepStone published late), is not returned. On: return it with changeType reposted instead of new.

## `watchName` (type: `string`):

Optional. Keeps separate memories for monitor mode, for example one per client (letters, digits, dot, dash, underscore; up to 40). Runs with the same watch name and the same search share what has already been returned.

## `resetMonitoringState` (type: `boolean`):

On: forget what this watch has seen for these searches before running, so this run is a first check again.

## Actor input object example

```json
{
  "searchQueries": [
    "Data Scientist"
  ],
  "locations": [
    "Berlin"
  ],
  "countries": [
    "de"
  ],
  "remoteWork": "any",
  "includeRelatedJobs": false,
  "includeJobDetails": false,
  "onlyNew": false,
  "includeReposted": false,
  "resetMonitoringState": false
}
```

# Actor output Schema

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

One row per StepStone job: job ID, title, company, location, date posted, remote work (hybrid or fully remote), salary with its source (StepStone estimate or posted), easy apply, match type (exact, nearby, related, recommended), link and position in the search. With job page details: employment type, deadline, industry, full description (contact names, phones and e-mails removed), postal code and coordinates. Monitor mode marks rows first-check, new or reposted. A search with no jobs, nothing new, a page robots.txt does not allow, a refused request or a run that hit its maximum charge comes back as a free row that says why.

# 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 = {
    "searchQueries": [
        "Data Scientist"
    ],
    "locations": [
        "Berlin"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("neverempty/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 = {
    "searchQueries": ["Data Scientist"],
    "locations": ["Berlin"],
}

# Run the Actor and wait for it to finish
run = client.actor("neverempty/stepstone-jobs-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 '{
  "searchQueries": [
    "Data Scientist"
  ],
  "locations": [
    "Berlin"
  ]
}' |
apify call neverempty/stepstone-jobs-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,neverempty/stepstone-jobs-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/nkWGgetuzvi7ar10p/builds/dhejg5P9qtpOpyxys/openapi.json