# StepStone.de Job Scraper (`scrapers-hub/stepstone-job-scraper`) Actor

StepStone Job scraper to extract publicly available job listings, company names, job titles, locations, salaries (when available), posting dates, and job details from StepStone 💼📊 Perfect for recruitment, job market research, talent sourcing, and employment trend analysis.

- **URL**: https://apify.com/scrapers-hub/stepstone-job-scraper.md
- **Developed by:** [Scrapers Hub](https://apify.com/scrapers-hub) (community)
- **Categories:** Jobs, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.99 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

### 🚀 StepStone Job Scraper — Extract Every Job Listing from StepStone.de

The **StepStone Job Scraper** is a fast, reliable, and fully-structured data extraction tool built to turn any StepStone.de search result page into clean, ready-to-use job data. Whether you are building a job board, powering a recruitment dashboard, training a hiring model, or running labor-market research, this **StepStone Job Scraper** gives you complete, deeply-structured job records with a single run. 🎯

Most simple scrapers 🪶 only grab a job title and a link. The **StepStone Job Scraper** goes far deeper. 🔬 It opens every individual job detail page, parses the embedded page state, and reconstructs the full job posting — company profile 🏢, salary insights 💶, posting metadata 🗓️, workplace arrangement 🏠, full description sections 📄, skills 🧠, badges 🏷️, and diagnostics 🩺. The result is a rich JSON dataset 📦 that feels like an internal database export rather than a thin surface scrape.

This **StepStone Job Scraper** was engineered for real-world reliability. The German job market site is protected by an advanced edge security layer that aggressively blocks naive bots. To handle this, the **StepStone Job Scraper** warms a real browser session, seeds the required security cookies, and then fans out high-speed concurrent requests using those trusted cookies. When a fast request is blocked, it automatically falls back to a full browser navigation — so you get both **speed and resilience** in one package. ⚡

If you have ever struggled 😤 to get consistent, complete data out of StepStone.de, this **StepStone Job Scraper** is built to solve exactly that problem, page after page 📃, job after job. 💼

---

### ✨ Key Features of the StepStone Job Scraper

The **StepStone Job Scraper** is not a quick script — it is a production-grade extraction engine. Below are the standout capabilities that make this **StepStone scraper** a complete solution. 🧩

#### 🔍 Deep, Full-Detail Job Extraction

Every job is opened individually 🔓 so you get the **entire posting**, not just the search-result preview. The **StepStone Job Scraper** extracts the full description, split into clean sections with paragraphs 📝, bullet points •, and links 🔗 preserved separately. This makes the output perfect for search indexing 🔎, NLP pipelines 🤖, and analytics 📈.

#### 🏢 Complete Company Intelligence

For each listing, the **StepStone Job Scraper** pulls a full company profile when available — company name 🏢, logo 🖼️, website 🌐, address 📍, company size 👥, founding year 📅, total open jobs 📌, industries 🏭, and sector classifications 🗂️. This turns a simple job feed into a powerful **employer database**. 💾

#### 💶 Salary & Compensation Data

Whenever StepStone.de exposes salary insights, the **StepStone Job Scraper** captures the compensation details block, so you can run pay-range analytics and benchmark roles across regions and seniorities.

#### ⚡ High-Speed Concurrent Scraping

The biggest speed lever is concurrency 🏎️. The **StepStone Job Scraper** fetches many detail pages in parallel using a thread pool 🧵. You control how aggressive it is with a single setting 🎚️, so you can balance raw speed ⚡ against stability 🧷 on any proxy.

#### 🛡️ Anti-Block Architecture

A warmed browser session seeds the edge security cookies first, then fast HTTP requests reuse those cookies. If a request still gets blocked, the **StepStone Job Scraper** automatically retries through a real browser. Blocked exit IPs are detected and rotated out of the pool, so the run keeps going instead of silently failing.

#### 📄 Smart Pagination

Point the **StepStone Job Scraper** at a single search URL and it walks through every result page automatically until your limit is reached or the results run out. No manual page-number juggling required.

#### 🧹 Clean, Normalized Output

URLs are normalized 🔧, HTML is converted to clean text 🧼, and every field is consistently named. The **StepStone Job Scraper** produces a predictable schema that drops straight into databases 🗄️, spreadsheets 📊, and BI tools 📉.

---

### 📥 Input & 📤 Output

This is the heart of how you drive the **StepStone Job Scraper**. You provide one or more StepStone.de search URLs, and you receive a structured list of fully-detailed job records. 🗂️

#### ⚙️ Input

The **StepStone Job Scraper** accepts a small, simple input object. Only `startUrls` is required — everything else has sensible defaults.

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| 🔗 `startUrls` | array | ✅ Yes | One or more StepStone.de search result URLs to scrape. |
| 🔢 `limit` | integer | ➖ No | Maximum number of jobs to collect. Default: `50000`. |
| ⚡ `detailConcurrency` | integer | ➖ No | How many detail pages to fetch in parallel. Default: `8`. Try `12–16` if your proxy holds up. |
| 🌐 `domain` | string | ➖ No | Target domain (informational). Default: `stepstone.de`. |
| 📏 `distanceFromSource` | string | ➖ No | Search radius in km, as encoded in the start URL (informational). |

##### 📝 Example Input

```json
{
  "startUrls": [
    "https://www.stepstone.de/jobs/engineer/in-frankfurt-am-main?radius=30&wfh=2"
  ],
  "limit": 500,
  "detailConcurrency": 8,
  "domain": "stepstone.de",
  "distanceFromSource": "30"
}
````

To scrape multiple searches at once 🔀, just add more URLs to the `startUrls` array — the **StepStone Job Scraper** will process each one in sequence ➡️ and combine the results into a single dataset. 🗃️

#### 📤 Output

Each job is returned as one rich JSON record 📦. The **StepStone Job Scraper** organizes every field into clear, logical groups 🗂️ so the data is easy to read 👀 and easy to query. 🔎

##### 📦 Example Output

```json
{
  "id": 11223344,
  "title": "Senior Software Engineer (m/w/d)",
  "seed_type": "url",
  "source": {
    "url": "https://www.stepstone.de/stellenangebote--senior-software-engineer.html",
    "source_url": "https://www.stepstone.de/jobs/engineer/in-frankfurt-am-main?radius=30",
    "seed_value": "https://www.stepstone.de/jobs/engineer/in-frankfurt-am-main?radius=30"
  },
  "scraped_at": "2026-06-30T10:15:00+00:00",
  "company_details": {
    "company_id": 55667,
    "company_name": "Example Tech GmbH",
    "company_profile_url": "/cmp/de/example-tech-55667",
    "company_logo_url": "https://image.stepstone.de/logo/55667.png",
    "is_anonymous_company": false,
    "company_website": "https://www.example-tech.de",
    "company_size": "201-500",
    "company_founded": "2009",
    "company_industries": ["Information Technology", "Software"]
  },
  "posting_details": {
    "published_at": "2026-06-28",
    "contract_type": "Permanent",
    "work_type": "Full-time",
    "online_status": "online"
  },
  "workplace_details": {
    "job_location": "Frankfurt am Main",
    "remote_work_type": "2",
    "work_arrangement": "Hybrid"
  },
  "listing_metadata": {
    "skills": ["Python", "Docker", "AWS"],
    "is_highlighted": true,
    "is_sponsored": false,
    "is_top_job": false
  },
  "content_details": {
    "full_description": "We are looking for a Senior Software Engineer to join our team...",
    "detail_sections": [
      {
        "name": "tasks",
        "title": "Your Responsibilities",
        "content_text": "Design and build scalable services...",
        "bullet_points": ["Develop backend APIs", "Mentor junior engineers"]
      }
    ]
  },
  "compensation_details": {
    "detail_salary": { "min": 65000, "max": 85000, "currency": "EUR" }
  }
}
```

Every record from the **StepStone Job Scraper** follows this same predictable shape, so you can rely on the field names when you build downstream pipelines. Missing data is simply omitted rather than guessed, keeping the output honest and clean. ✅

***

### 🏆 Why the StepStone Job Scraper Stands Out

There are many ways to pull data from a job site, but few deliver the depth, reliability, and structure of this **StepStone Job Scraper**. Here is what sets it apart. 🌟

#### 🧠 Built for Real Data, Not Surface Scraping

A lot of tools stop at the search-result snippet 🛑. The **StepStone Job Scraper** treats every listing as a full document 📃, reconstructing the complete posting exactly as a real visitor 👤 would see it. That difference matters enormously when your downstream analysis depends on full descriptions, skills 🧠, and company facts 🏢.

#### 🔧 Tunable and Predictable

Because every field follows a stable schema 📐, your code never breaks 🧱 on surprise structures. The **StepStone Job Scraper** also exposes the few knobs 🎛️ that actually matter — concurrency ⚡ and limit 🔢 — instead of burying you in options. You stay in control 🕹️ without the complexity.

#### 💪 Resilient by Design

Edge protection 🧱, rate limits ⏱️, and blocked IPs 🚫 are facts of life on large sites. The **StepStone Job Scraper** treats them as normal conditions to manage, not fatal errors. Warm-up 🔥, cookie reuse 🍪, browser fallback 🧭, and IP rotation 🔄 work together so your runs finish ✅ even when individual requests struggle.

#### 🌍 Localized and Accurate

The **StepStone Job Scraper** runs with the correct locale and language headers, so the data it returns matches what a real German-market visitor sees — accurate titles, locations, and descriptions, with no garbled or mismatched content.

***

### 🎯 Use Cases

The structured data from the **StepStone Job Scraper** unlocks a wide range of practical applications. 💡

#### 🧑‍💼 Recruitment & Sourcing

Build a continuously-updated talent pipeline 🔄. The **StepStone Job Scraper** lets recruiters 🧑‍💼 monitor new openings by role, region 📍, and remote arrangement 🏠, then react faster ⚡ than competitors who refresh listings manually.

#### 📊 Labor Market Research

Aggregate thousands of postings 📚 to study hiring trends 📈, in-demand skills 🧠, contract types 📑, and salary ranges 💶. The **StepStone Job Scraper** makes large-scale market analysis straightforward because every record is already normalized. ✨

#### 🤖 AI & Machine Learning Datasets

Job descriptions, skills, and structured sections are ideal training material for resume-matching models, classification systems, and recommendation engines. The clean output of the **StepStone Job Scraper** saves you huge amounts of preprocessing time.

#### 🏗️ Job Board Aggregation

Power your own job board or vertical search engine. With full descriptions, company profiles, and apply links, the **StepStone Job Scraper** provides everything you need to display complete listings to your users.

#### 🏢 Competitive & Company Intelligence

Track which companies are hiring 🏢, how fast they grow their teams 📈, and which skills they prioritize 🧠. The employer data from the **StepStone Job Scraper** turns scattered listings into actionable competitive insight. 🔍

***

### 🛠️ How the StepStone Job Scraper Works

Understanding the engine helps you tune it for the best results. ⚙️

#### 🌐 Step 1 — Session Warm-Up

The **StepStone Job Scraper** launches a real browser 🌐, visits the homepage 🏠, and lets the site's security layer issue the cookies 🍪 it expects from a genuine visitor. This step is what allows the fast path ⚡ to succeed later.

#### 📃 Step 2 — Search & Pagination

Using the warmed session 🔥, the scraper walks through each search result page 📃, collecting genuine job items ✅ while skipping filter and facet entries 🚮. It continues until your `limit` is reached 🎯 or no new jobs appear.

#### ⚡ Step 3 — Concurrent Detail Fetching

The **StepStone Job Scraper** then fetches every detail page in parallel, carrying the trusted cookies for speed. This is the fast path and handles the vast majority of jobs.

#### 🔁 Step 4 — Browser Fallback

For the small number of pages the fast path cannot retrieve, the **StepStone Job Scraper** falls back to navigating with the real browser, which reliably passes protection once warmed.

#### 🧱 Step 5 — Record Assembly

Finally, each page is parsed 🧩 and assembled into the clean, grouped JSON record 📦 shown above, ready for immediate use. ✅

***

### ⚙️ Configuration Tips

Get the most out of the **StepStone Job Scraper** with these practical recommendations. 🔧

#### 🚦 Tuning Concurrency

Start with the default `detailConcurrency` of `8` 🎚️. If your proxy is strong 💪 and stable, raise it to `12–16` for noticeably faster runs ⚡. If you see more blocks 🚫, lower it ⬇️. The **StepStone Job Scraper** is designed to keep going either way. 🔁

#### 🎯 Targeting the Right Jobs

Use StepStone.de's own filters — location, radius, remote work, recency — directly in your search URL. The **StepStone Job Scraper** respects whatever is encoded in the URL, so a well-built search means cleaner, more relevant results.

#### 📈 Scaling Up

Need everything in a category? 📚 Set a high `limit` and let pagination run. Need a quick sample? 🧪 Set a low `limit` to test your setup before a full run. The **StepStone Job Scraper** handles both extremes gracefully. 🤸

***

### ❓ Frequently Asked Questions

#### 📄 Does the StepStone Job Scraper get full job descriptions?

Yes. The **StepStone Job Scraper** opens each individual detail page and extracts the complete description, broken into clean sections with paragraphs, bullet points, and links preserved.

#### 🔀 Can it scrape multiple searches at once?

Absolutely. Add several URLs to `startUrls` and the **StepStone Job Scraper** processes each search and merges all jobs into one dataset.

#### 🛡️ What happens if a page is blocked?

The **StepStone Job Scraper** automatically retries through a real browser and rotates away from blocked exit IPs, so your run continues rather than failing.

#### ⚡ How fast is it?

Speed depends mostly on concurrency and proxy quality. With a healthy setup, the **StepStone Job Scraper** can process listings quickly thanks to its parallel detail-fetching design. ⚡

***

### 🎉 Get Started

The **StepStone Job Scraper** turns the German job market 🇩🇪 into clean, structured, ready-to-use data with almost no setup. Provide a search URL 🔗, choose your limit 🔢, and let the scraper handle warm-up 🔥, pagination 📃, concurrency ⚡, fallback 🧭, and parsing 🧩 for you.

Stop fighting with brittle one-off scripts. Start collecting complete, reliable job data today with the **StepStone Job Scraper** — and build whatever comes next on top of a dataset you can trust. 🚀

# Actor input Schema

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

One or more StepStone.de search result URLs to scrape.

## `limit` (type: `integer`):

Maximum number of job listings to scrape.

## `detailConcurrency` (type: `integer`):

How many job detail pages to fetch in parallel. Higher = faster, but too high may trip rate limits/blocks. 8 is a safe default; try 12-16 if the proxy holds up.

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

Target StepStone domain (informational).

## `distanceFromSource` (type: `string`):

Search radius, as encoded in the start URL (informational).

## Actor input object example

```json
{
  "startUrls": [
    "https://www.stepstone.de/jobs/engineer/in-frankfurt-am-main?whereType=autosuggest&radius=30&action=facet_selected%3bworkFromHome%3b2&ag=age_1&wfh=2&searchOrigin=Resultlist_top-search"
  ],
  "limit": 50000,
  "detailConcurrency": 8,
  "domain": "stepstone.de",
  "distanceFromSource": "30"
}
```

# 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 = {
    "startUrls": [
        "https://www.stepstone.de/jobs/engineer/in-frankfurt-am-main?whereType=autosuggest&radius=30&action=facet_selected%3bworkFromHome%3b2&ag=age_1&wfh=2&searchOrigin=Resultlist_top-search"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapers-hub/stepstone-job-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 = { "startUrls": ["https://www.stepstone.de/jobs/engineer/in-frankfurt-am-main?whereType=autosuggest&radius=30&action=facet_selected%3bworkFromHome%3b2&ag=age_1&wfh=2&searchOrigin=Resultlist_top-search"] }

# Run the Actor and wait for it to finish
run = client.actor("scrapers-hub/stepstone-job-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 '{
  "startUrls": [
    "https://www.stepstone.de/jobs/engineer/in-frankfurt-am-main?whereType=autosuggest&radius=30&action=facet_selected%3bworkFromHome%3b2&ag=age_1&wfh=2&searchOrigin=Resultlist_top-search"
  ]
}' |
apify call scrapers-hub/stepstone-job-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "StepStone.de Job Scraper",
        "description": "StepStone Job scraper to extract publicly available job listings, company names, job titles, locations, salaries (when available), posting dates, and job details from StepStone 💼📊 Perfect for recruitment, job market research, talent sourcing, and employment trend analysis.",
        "version": "1.0",
        "x-build-id": "rfCPVJyLZz5kugIxW"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapers-hub~stepstone-job-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapers-hub-stepstone-job-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/scrapers-hub~stepstone-job-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapers-hub-stepstone-job-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/scrapers-hub~stepstone-job-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapers-hub-stepstone-job-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": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "One or more StepStone.de search result URLs to scrape.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "limit": {
                        "title": "Max jobs",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of job listings to scrape.",
                        "default": 50000
                    },
                    "detailConcurrency": {
                        "title": "Detail concurrency",
                        "minimum": 1,
                        "maximum": 32,
                        "type": "integer",
                        "description": "How many job detail pages to fetch in parallel. Higher = faster, but too high may trip rate limits/blocks. 8 is a safe default; try 12-16 if the proxy holds up.",
                        "default": 8
                    },
                    "domain": {
                        "title": "Domain",
                        "type": "string",
                        "description": "Target StepStone domain (informational).",
                        "default": "stepstone.de"
                    },
                    "distanceFromSource": {
                        "title": "Distance from source (km)",
                        "type": "string",
                        "description": "Search radius, as encoded in the start URL (informational).",
                        "default": "30"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
