# Stepstone Job Scraper (`automation-lab/stepstone-scraper`) Actor

Scrape job listings from Stepstone.de — Germany's #1 job board. Extract job title, company, location, salary range, employment type, and work-from-home status. Export to JSON, CSV, or Excel. No API key needed.

- **URL**: https://apify.com/automation-lab/stepstone-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Jobs
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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 a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

### What does the Stepstone Job Scraper do?

The **Stepstone Job Scraper** extracts job listings from [Stepstone.de](https://www.stepstone.de) — Germany's largest job board with 100,000+ active postings. Enter one or more keywords and an optional city to get structured job data: title, company, location, salary range, employment type, work-from-home status, and direct links to apply.

Stepstone.de is a pure HTTP site — no browser needed. This scraper uses lightweight HTTP requests, so it runs on 256 MB RAM (8× cheaper than browser-based competitors) and returns results in seconds.

Try it now: [Stepstone Job Scraper on Apify Store](https://apify.com/automation-lab/stepstone-scraper)

### Who is the Stepstone Job Scraper for?

**🧑‍💼 HR teams and recruiters**
- Monitor the job market for a specific role across Germany
- Track competitor job postings and hiring velocity
- Build candidate sourcing pipelines with fresh daily data

**📊 Market researchers and labour economists**
- Analyze salary trends by city, role, and industry
- Map workforce demand across German regions
- Study employment type distributions (full-time vs. contract vs. part-time)

**🛠️ Developers and data engineers**
- Power internal job boards or recommendation engines
- Feed HR analytics dashboards with live Stepstone data
- Automate job alert systems for candidates in your product

**📈 Business intelligence teams**
- Track hiring trends at specific companies
- Benchmark job density in target markets for expansion planning
- Export cleaned data to Google Sheets, Airtable, or data warehouses

### Why use the Stepstone Job Scraper?

- ✅ **Lightweight and fast** — pure HTTP with got-scraping, no headless browser, runs on 256 MB (competitors use 2048 MB)
- ✅ **No API key or account required** — works out of the box
- ✅ **Structured output** — flat JSON with consistent field names; no post-processing required
- ✅ **Full pagination support** — get 25 to 2,700+ results per search query
- ✅ **Multiple keywords** — run several searches in one actor call
- ✅ **Radius search** — filter by city + distance in km
- ✅ **Export anywhere** — JSON, CSV, Excel, or connect to 1,000+ apps via Apify integrations
- ✅ **Scheduled runs** — automate daily or weekly scraping with Apify's built-in scheduler

### What data can you extract from Stepstone.de?

Each scraped job listing includes these fields:

| Field | Description | Example |
|-------|-------------|---------|
| `id` | Stepstone job ID | `"13510716"` |
| `title` | Full job title | `"Software Engineer (w/m/d)"` |
| `companyName` | Employer name | `"Capgemini Deutschland GmbH"` |
| `companyLogoUrl` | URL to company logo image | `"https://www.stepstone.de/upload_DE/..."` |
| `url` | Direct link to the job posting | `"https://www.stepstone.de/stellenangebote--..."` |
| `location` | City or cities | `"Berlin"` or `"Berlin, Hamburg, München"` |
| `postCode` | Postal code (when available) | `"10115"` |
| `salaryText` | Formatted salary range | `"60.000 - 80.000 EUR"` |
| `salaryMin` | Minimum salary (numeric, EUR) | `60000` |
| `salaryMax` | Maximum salary (numeric, EUR) | `80000` |
| `salaryCurrency` | Salary currency | `"EUR"` |
| `datePosted` | ISO 8601 posting date | `"2026-03-31T12:20:02+02:00"` |
| `workFromHome` | Remote/hybrid work available | `true` or `false` |
| `employmentType` | Contract type | `"Full-time"`, `"Part-time"`, `"Contract"` |
| `scrapedAt` | Timestamp of extraction | `"2026-04-01T04:10:00.000Z"` |

> **Note on salary:** German employers are not required to publish salary ranges, so many Stepstone listings omit salary data. The `salaryText`, `salaryMin`, and `salaryMax` fields will be `null` when no salary is provided by the employer.

### How much does it cost to scrape Stepstone.de?

This actor uses **Pay-Per-Event (PPE) pricing** — you pay only for what you scrape, with no minimum commitment.

| Event | FREE tier | BRONZE | SILVER | GOLD | PLATINUM | DIAMOND |
|-------|-----------|--------|--------|------|----------|---------|
| Run started | $0.005 | $0.005 | $0.005 | $0.005 | $0.005 | $0.005 |
| Per job scraped | $0.0023 | $0.0020 | $0.00156 | $0.0012 | $0.0008 | $0.00056 |

**Real-world cost examples:**

| Scenario | Jobs | Approx. cost (FREE) | Approx. cost (GOLD) |
|----------|------|---------------------|---------------------|
| Quick test | 20 | ~$0.051 | ~$0.029 |
| Single keyword search | 100 | ~$0.235 | ~$0.125 |
| Multi-keyword research | 500 | ~$1.16 | ~$0.61 |
| Daily monitoring batch | 2,000 | ~$4.61 | ~$2.41 |

**Free plan:** Apify gives every new account $5 in free credits. That's enough to scrape ~2,100 job listings on the FREE tier — plenty to evaluate this tool before committing.

### How to scrape Stepstone.de step by step

1. **Go to the actor page**: [apify.com/automation-lab/stepstone-scraper](https://apify.com/automation-lab/stepstone-scraper)
2. **Click "Try for free"** — create a free Apify account if you don't have one
3. **Enter your keywords** — job titles or roles (e.g., `Software Engineer`, `Projektmanager`, `Data Analyst`)
4. **Set a location** (optional) — city name like `Berlin`, `München`, or `Hamburg`
5. **Set a radius** — how many km around that city to search (default: 30 km)
6. **Set max results** — how many jobs to scrape (default: 100; up to 10,000+)
7. **Click "Save & Run"** — the actor starts immediately
8. **Download results** — export to JSON, CSV, Excel, or connect to your pipeline

**Example input for software jobs in Berlin:**
```json
{
    "keywords": ["Software Engineer", "Backend Developer"],
    "location": "Berlin",
    "radiusKm": 30,
    "maxResults": 200
}
````

**Example input for HR analytics — Germany-wide search:**

```json
{
    "keywords": ["Personalreferent", "HR Manager", "Recruiter"],
    "maxResults": 500
}
```

**Example input for a single quick test:**

```json
{
    "keywords": ["Data Scientist"],
    "location": "München",
    "radiusKm": 50,
    "maxResults": 25
}
```

### Input parameters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `keywords` | array of strings | required | Job search keywords. Each keyword runs as a separate search. Use German or English terms. |
| `location` | string | `""` (all Germany) | City or region to filter by. Examples: `Berlin`, `München`, `Frankfurt am Main`. |
| `radiusKm` | integer | `30` | Search radius in km around the location. Only applies when `location` is set. Range: 0–200. |
| `maxResults` | integer | `100` | Maximum total jobs to scrape across all keywords. Increase for bulk research. |
| `maxRequestRetries` | integer | `3` | Retries for failed HTTP requests. Increase if you see intermittent failures. |

### Output examples

A typical output item looks like:

```json
{
    "id": "13510716",
    "title": "Software Engineer (w/m/d)",
    "companyName": "Capgemini Deutschland GmbH",
    "companyLogoUrl": "https://www.stepstone.de/upload_DE/logo/9/logoCapgemini-Deutschland-GmbH-2692DE-2601160927.gif",
    "url": "https://www.stepstone.de/stellenangebote--Software-Engineer-w-m-d-Berlin-Capgemini-Deutschland-GmbH--13510716-inline.html",
    "location": "Berlin",
    "postCode": null,
    "salaryText": null,
    "salaryMin": null,
    "salaryMax": null,
    "salaryCurrency": null,
    "datePosted": "2026-03-31T12:20:02+02:00",
    "workFromHome": true,
    "employmentType": null,
    "scrapedAt": "2026-04-01T04:13:57.558Z"
}
```

A job with salary data:

```json
{
    "id": "13600100",
    "title": "Senior Buchhalter (m/w/d)",
    "companyName": "KPMG AG",
    "companyLogoUrl": "https://www.stepstone.de/upload_DE/logo/...",
    "url": "https://www.stepstone.de/stellenangebote--Senior-Buchhalter-m-w-d-Frankfurt-KPMG--13600100-inline.html",
    "location": "Frankfurt am Main",
    "postCode": "60308",
    "salaryText": "55.000 - 75.000 EUR",
    "salaryMin": 55000,
    "salaryMax": 75000,
    "salaryCurrency": "EUR",
    "datePosted": "2026-03-28T08:00:00+02:00",
    "workFromHome": false,
    "employmentType": "Vollzeit",
    "scrapedAt": "2026-04-01T04:13:57.000Z"
}
```

### Tips for best results

- 🔍 **Use German job titles for more results** — Stepstone.de is primarily German-language. Searching `Softwareentwickler` returns more German-specific results than `Software Engineer`, though both work.
- 📍 **Try different radius values** — A 30 km radius works well for cities. Use 100–200 km for regional coverage or 0 for exact city matches.
- 🔁 **Schedule daily runs** — Stepstone listings are refreshed frequently. Set up a recurring run (Apify scheduler) to maintain a fresh dataset.
- 📊 **Export to Google Sheets** — Use the Google Sheets integration to build a live job market dashboard that auto-refreshes.
- 🧩 **Use multiple keywords** — A single actor run can handle 5–10 keywords, returning results from each. Separate results by checking the keyword each job was found with (results are ordered by keyword).
- 💰 **Keep `maxResults` low during testing** — Start with 25 to validate your keywords before scaling to 500+.
- 🕐 **Run during business hours (German time)** — Stepstone posting volume peaks Monday–Wednesday mornings (CET). Fresh listings appear faster if you scrape between 8–11 AM.

### Integrations

**Stepstone → Google Sheets (live job market dashboard)**

Connect the actor output to Google Sheets using the Apify integration. Set up a scheduled run every morning at 7 AM to get fresh job data automatically. Build a pivot table to track hiring velocity by company or location.

**Stepstone → Slack / Teams (job alert bot)**

Use Apify Webhooks to trigger a Slack message whenever the actor finds new postings for a specific keyword. Set up a webhook that posts to `#job-alerts` with the job title, company, and URL. Combine with a filter task to only alert on senior roles or remote positions.

**Stepstone → Airtable (candidate tracking)**

Push Stepstone results directly into an Airtable base using the Apify → Airtable integration. Create a base with columns matching the output fields. Run the actor daily and deduplicate by job ID to maintain a curated, searchable database.

**Stepstone → BigQuery / Snowflake (BI pipeline)**

Use the Apify API to pull JSON results into your data warehouse on a cron schedule. Join with your internal HR data or competitor intelligence to build workforce analytics models.

**Scheduled monitoring run**

```json
{
    "keywords": ["Produktmanager", "Product Manager"],
    "location": "Berlin",
    "maxResults": 100
}
```

Run this every day at 6 AM. Get notified when new listings appear and track which companies are hiring for this role.

### Using the Apify API

You can call the Stepstone Scraper programmatically via the Apify API.

#### Node.js

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

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

const run = await client.actor('automation-lab/stepstone-scraper').call({
    keywords: ['Software Engineer'],
    location: 'Berlin',
    radiusKm: 30,
    maxResults: 100,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Scraped ${items.length} jobs`);
items.forEach(job => console.log(job.title, '—', job.companyName, '—', job.location));
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient(token="YOUR_APIFY_TOKEN")

run = client.actor("automation-lab/stepstone-scraper").call(run_input={
    "keywords": ["Software Engineer", "Backend Developer"],
    "location": "Berlin",
    "radiusKm": 30,
    "maxResults": 100,
})

items = client.dataset(run["defaultDatasetId"]).list_items().items
print(f"Scraped {len(items)} jobs")
for job in items:
    print(f"{job['title']} — {job['companyName']} — {job['location']}")
```

#### cURL

```bash
## Start a run
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~stepstone-scraper/runs?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "keywords": ["Projektmanager"],
    "location": "München",
    "radiusKm": 50,
    "maxResults": 100
  }'

## Fetch results (replace RUN_ID and DATASET_ID with values from run response)
curl "https://api.apify.com/v2/datasets/DATASET_ID/items?token=YOUR_APIFY_TOKEN&format=json"
```

### Use with AI agents via MCP

Stepstone Job Scraper is available as a tool for AI assistants that support the [Model Context Protocol (MCP)](https://docs.apify.com/platform/integrations/mcp).

Add the Apify MCP server to your AI client — this gives you access to all Apify actors, including this one:

#### Setup for Claude Code

```bash
claude mcp add --transport http apify "https://mcp.apify.com"
```

#### Setup for Claude Desktop, Cursor, or VS Code

Add this to your MCP config file:

```json
{
    "mcpServers": {
        "apify": {
            "url": "https://mcp.apify.com"
        }
    }
}
```

Your AI assistant will use OAuth to authenticate with your Apify account on first use.

#### Example prompts

Once connected, try asking your AI assistant:

- "Use automation-lab/stepstone-scraper to find all Data Engineer jobs in Frankfurt within 50 km posted this week"
- "Scrape 200 software developer jobs from Stepstone.de in Berlin and tell me which companies are hiring the most"
- "Get the latest Backend Developer listings from Stepstone for Hamburg and export them to a CSV"

Learn more in the [Apify MCP documentation](https://docs.apify.com/platform/integrations/mcp).

### Is it legal to scrape Stepstone.de?

Web scraping publicly available data for non-commercial research, journalism, or personal use is generally considered lawful in the EU under the principle that publicly accessible information on the internet can be freely accessed. Stepstone.de displays job listings without requiring a login or account — this data is intentionally public.

**Important guidelines for responsible use:**

- Only scrape publicly visible data — do not attempt to access login-protected pages
- Respect `robots.txt` as a guide to the site's preferences (though not legally binding in most EU jurisdictions)
- Use the data in compliance with GDPR — do not store personal data of identifiable individuals longer than necessary
- Do not use this tool to republish Stepstone's content commercially or in a way that competes with their core business
- Rate-limit your requests — this actor includes built-in delays to avoid overloading Stepstone's servers

This actor is intended for **HR analytics, labor market research, candidate sourcing tooling, and business intelligence**. If you are unsure whether your specific use case is compliant with Stepstone's Terms of Service or local law, consult a legal professional.

Apify's [Web Scraping Legal Explainer](https://apify.com/resources/web-scraping-legal-explainer) provides a broader overview.

### FAQ

**How many jobs can I scrape per keyword?**
Stepstone.de shows up to 2,700+ results per search query. The actor paginates through all available pages (25 jobs per page). For most keyword + location combinations, you'll find 25–500 results. Broad searches like `"Ingenieur" in Germany` may return 2,000+.

**How much does it cost to scrape 100 jobs?**
On the FREE tier: ~$0.235 (100 jobs × $0.0023 + $0.005 start fee). On the GOLD tier: ~$0.125. See the Pricing section above for more examples.

**Why are salary fields empty for most listings?**
German employers are not legally required to disclose salary ranges. In practice, fewer than 20% of Stepstone.de listings include salary data. When salary is available, the `salaryText`, `salaryMin`, `salaryMax`, and `salaryCurrency` fields are populated. When not available, they are `null` — not a scraper bug.

**Why does `workFromHome` show `true` for many jobs?**
Stepstone uses a numeric code internally: `"0"` = fully on-site, `"2"` = hybrid or remote-friendly. The actor maps any non-"0" value to `workFromHome: true`. If you need to distinguish hybrid from fully remote, note that Stepstone's search results data does not expose this level of detail — you would need to visit the individual job page.

**How fast is the scraper?**
Typical throughput is 25–50 jobs per minute (limited by request delays to be polite). A search of 100 jobs takes ~2–4 minutes. A large batch of 2,000 jobs takes ~40–80 minutes.

**Can I scrape jobs from other Stepstone markets (Belgium, Netherlands, Denmark, Austria)?**
This actor is designed for Stepstone.de (Germany). Other country sites use slightly different URL structures. If you need data from stepstone.be, stepstone.nl, or equivalent, contact the actor author.

**Why do I see results for seemingly wrong keywords?**
Stepstone's search engine uses semantic matching and always returns recommended results, even for obscure or misspelled keywords. If you search `zzz-test-xyz`, you'll still get ~500 general listings from Stepstone's recommendation engine. This is Stepstone behavior, not a scraper bug.

**Why are some pages returning duplicate jobs?**
Stepstone's recommendation/regional extension system may show the same listing on multiple result pages. The actor deduplicates by job ID, so your final dataset contains only unique listings.

### Other job scrapers

Looking for job data from other markets? Check out these automation-lab actors:

- [Seek.com.au Job Scraper](https://apify.com/automation-lab/seek-scraper) — Australia's #1 job board
- [Naukri.com Job Scraper](https://apify.com/automation-lab/naukri-scraper) — India's largest job portal
- [LinkedIn Jobs Scraper](https://apify.com/automation-lab/linkedin-jobs-scraper) — Global LinkedIn job listings
- [Google Jobs Scraper](https://apify.com/automation-lab/google-jobs-scraper) — Jobs indexed by Google across all sources
- [Greenhouse Jobs Scraper](https://apify.com/automation-lab/greenhouse-jobs-scraper) — Tech company jobs via Greenhouse ATS

# Actor input Schema

## `keywords` (type: `array`):

Enter one or more job keywords to search on Stepstone.de. Each keyword runs as a separate search. Examples: 'Software Engineer', 'Projektmanager', 'Data Analyst'. Use German or English terms.

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

Filter jobs by city or region in Germany. Leave blank to search all of Germany. Examples: 'Berlin', 'München', 'Hamburg', 'Frankfurt am Main', 'Köln'.

## `radiusKm` (type: `integer`):

Search radius in kilometers around the selected location. Only applies when a location is specified. Set to 0 for exact city match.

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

Maximum total number of job listings to scrape across all keywords. Each page returns 50 jobs. Default: 100. Increase for bulk scraping.

## `maxRequestRetries` (type: `integer`):

Number of times to retry failed HTTP requests before skipping. Higher values improve reliability on slow connections.

## Actor input object example

```json
{
  "keywords": [
    "Software Engineer"
  ],
  "location": "Berlin",
  "radiusKm": 30,
  "maxResults": 20,
  "maxRequestRetries": 3
}
```

# Actor output Schema

## `overview` (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 = {
    "keywords": [
        "Software Engineer"
    ],
    "location": "Berlin",
    "radiusKm": 30,
    "maxResults": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/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 = {
    "keywords": ["Software Engineer"],
    "location": "Berlin",
    "radiusKm": 30,
    "maxResults": 20,
}

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

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

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

```

## CLI example

```bash
echo '{
  "keywords": [
    "Software Engineer"
  ],
  "location": "Berlin",
  "radiusKm": 30,
  "maxResults": 20
}' |
apify call automation-lab/stepstone-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Stepstone Job Scraper",
        "description": "Scrape job listings from Stepstone.de — Germany's #1 job board. Extract job title, company, location, salary range, employment type, and work-from-home status. Export to JSON, CSV, or Excel. No API key needed.",
        "version": "0.1",
        "x-build-id": "H7QVbDhugZ6lh6xsp"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~stepstone-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-stepstone-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/automation-lab~stepstone-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-stepstone-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/automation-lab~stepstone-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-stepstone-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "keywords"
                ],
                "properties": {
                    "keywords": {
                        "title": "🔍 Keywords",
                        "type": "array",
                        "description": "Enter one or more job keywords to search on Stepstone.de. Each keyword runs as a separate search. Examples: 'Software Engineer', 'Projektmanager', 'Data Analyst'. Use German or English terms.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "📍 Location",
                        "type": "string",
                        "description": "Filter jobs by city or region in Germany. Leave blank to search all of Germany. Examples: 'Berlin', 'München', 'Hamburg', 'Frankfurt am Main', 'Köln'."
                    },
                    "radiusKm": {
                        "title": "📏 Radius (km)",
                        "minimum": 0,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Search radius in kilometers around the selected location. Only applies when a location is specified. Set to 0 for exact city match.",
                        "default": 30
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum total number of job listings to scrape across all keywords. Each page returns 50 jobs. Default: 100. Increase for bulk scraping.",
                        "default": 100
                    },
                    "maxRequestRetries": {
                        "title": "Max request retries",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Number of times to retry failed HTTP requests before skipping. Higher values improve reliability on slow connections.",
                        "default": 3
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```