# Lagou Tech Jobs Scraper (拉勾网) (`logiover/lagou-tech-jobs-scraper`) Actor

Extract thousands of tech job listings from Lagou.com (拉勾网), China's largest IT recruitment platform. Scrape salary ranges, tech stacks, company details, funding stages, and more from ByteDance, Alibaba, Tencent, Baidu, and 100,000+ Chinese tech companies. No browser needed — fast, cheap, scalable.

- **URL**: https://apify.com/logiover/lagou-tech-jobs-scraper.md
- **Developed by:** [Logiover](https://apify.com/logiover) (community)
- **Categories:** Jobs, Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.50 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are 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

## Lagou Tech Jobs Scraper (拉勾网) — China's #1 Tech Job Data Extractor

Extract **thousands of tech job listings** from [Lagou.com](https://www.lagou.com) (拉勾网), China's largest and most popular technology-focused recruitment platform. Get structured data on salaries, tech stacks, company funding stages, and more from top Chinese tech companies including **ByteDance (字节跳动), Alibaba (阿里巴巴), Tencent (腾讯), Baidu (百度), Meituan (美团), JD.com (京东), Xiaomi (小米), Huawei (华为), Pinduoduo (拼多多), NetEase (网易), Didi (滴滴), Kuaishou (快手)** and thousands more.

### Why This Scraper?

Lagou.com is the **dominant job board for China's tech industry** with 500,000+ active listings across all major Chinese cities. Unlike generic Chinese job sites (Zhaopin, 51Job, BOSS Zhipin), Lagou focuses exclusively on **technology, software engineering, product management, data science, AI/ML, and digital roles** — making the data highly targeted and valuable.

This scraper delivers **structured, clean JSON data** ready for analysis, research, dashboards, and integration — no manual copying, no browser automation, no headless browsers.

### Key Features

- **Fast & Cheap** — Direct HTTP extraction, no browser needed. Runs on minimal memory (128 MB). ~$3.00 per 1,000 jobs
- **Massive Scale** — Collects thousands of unique jobs per run using intelligent combo expansion (keywords × cities × experience filters)
- **Smart Deduplication** — Built-in position ID tracking ensures zero duplicate records across all search combinations
- **Parallel Processing** — Configurable concurrency (up to 10 parallel workers) for maximum throughput
- **Experience Filter Expansion** — Automatically multiplies searches by 6 experience levels, surfacing jobs hidden behind filters
- **25+ Chinese Cities** — Pre-mapped support for all major tech hubs with English or Chinese city name input
- **Salary Parsing** — Automatically extracts numeric min/max salary from Chinese formats (15k-25k, 1万-2万)
- **Rich Company Data** — Funding stage, employee count, industry classification, company logo for every listing
- **Proxy-Ready** — Designed for residential proxy rotation; each request uses a fresh IP

### Output Data Fields (27 Fields)

Every scraped job includes the following structured fields:

| Field | Type | Example | Description |
|-------|------|---------|-------------|
| `jobTitle` | string | `Python开发工程师` | Full position title |
| `jobUrl` | string | `https://www.lagou.com/wn/jobs/123.html` | Direct link to listing |
| `companyName` | string | `微梦创科网络科技（中国）有限公司` | Official company name |
| `companyShortName` | string | `微博` | Company brand name |
| `companyUrl` | string | `https://www.lagou.com/gongsi/5832.html` | Company profile link |
| `salary` | string | `20k-40k` | Raw salary string |
| `salaryMin` | integer | `20` | Parsed minimum monthly salary (thousands RMB) |
| `salaryMax` | integer | `40` | Parsed maximum monthly salary (thousands RMB) |
| `city` | string | `北京` | Job city |
| `district` | string | `海淀区` | City district |
| `workYear` | string | `1-3年` | Required experience |
| `education` | string | `本科` | Minimum education |
| `jobNature` | string | `全职` | Full-time / Part-time |
| `jobType` | string | `开发\|测试\|运维类` | Job category |
| `skills` | string | `Python, MySQL, Redis, Docker` | Required tech stack |
| `companySize` | string | `2000人以上` | Company size range |
| `industryField` | string | `社交媒体` | Industry sector |
| `financeStage` | string | `上市公司` | Funding stage (IPO, Series A-D, etc.) |
| `companyLogo` | string | `https://...jpg` | Company logo URL |
| `jobDescription` | string | *(optional)* | Full job description text |
| `publishTime` | string | `2026-04-18 15:13:30` | Listing publish timestamp |
| `positionId` | integer | `12196627` | Lagou internal job ID |
| `companyId` | integer | `5832` | Lagou internal company ID |
| `searchKeyword` | string | `Python` | Keyword that found this job |
| `searchCity` | string | `北京` | City filter used |
| `pageNumber` | integer | `1` | Result page number |
| `scrapedAt` | string | `2026-04-18T10:04:51Z` | Scrape timestamp (ISO) |

### Use Cases

- **Salary Benchmarking** — Compare Python vs Java vs Go developer salaries across Beijing, Shanghai, Shenzhen, Hangzhou, and other cities
- **Tech Stack Analysis** — Identify the most in-demand programming languages, frameworks, and tools in China's tech market
- **Hiring Trend Monitoring** — Track which companies are hiring aggressively, which sectors are growing
- **Company Research** — Map the Chinese tech ecosystem by funding stage, size, industry, and hiring volume
- **Recruitment Intelligence** — Build candidate sourcing pipelines with targeted job market data
- **Academic Research** — Study China's technology labor market, regional tech hub development, wage inequality
- **Market Entry Analysis** — Understand local tech talent landscape before entering the Chinese market
- **Competitive Intelligence** — Monitor competitors' hiring patterns and tech stack choices
- **Investment Due Diligence** — Assess company growth through hiring velocity and role types
- **Data Journalism** — Create stories about China's tech industry trends backed by hard data

### Supported Cities (25+)

All major Chinese tech hubs are supported with **English or Chinese input**:

| English | Chinese | Tech Hub Rank |
|---------|---------|---------------|
| beijing | 北京 | #1 — AI, fintech, ByteDance HQ |
| shanghai | 上海 | #2 — Finance-tech, gaming |
| shenzhen | 深圳 | #3 — Hardware, Tencent/Huawei HQ |
| hangzhou | 杭州 | #4 — E-commerce, Alibaba HQ |
| guangzhou | 广州 | #5 — Internet services |
| chengdu | 成都 | #6 — Gaming, growing startup hub |
| nanjing | 南京 | #7 — Enterprise software |
| wuhan | 武汉 | #8 — Optics, semiconductor |
| xian | 西安 | #9 — Aerospace, emerging tech |
| suzhou | 苏州 | #10 — Biotech, manufacturing-tech |
| changsha | 长沙 | tianjin, chongqing, xiamen |
| fuzhou | 福州 | hefei, dongguan, jinan |
| kunming | 昆明 | zhuhai, ningbo, wuxi |
| dalian | 大连 | qingdao, zhengzhou, and more |

### Input Configuration

```json
{
  "keywords": ["Python", "Java", "React", "Go", "AI"],
  "cities": ["beijing", "shanghai", "shenzhen", "hangzhou", "chengdu"],
  "expandFilters": true,
  "maxJobsTotal": 0,
  "maxConcurrency": 3,
  "requestDelay": 1000,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
````

#### Input Parameters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `keywords` | string\[] | *required* | Search keywords (Python, Java, React, Go, AI, DevOps, etc.) |
| `cities` | string\[] | `["beijing"]` | Cities to search — English or Chinese names accepted |
| `expandFilters` | boolean | `true` | Multiply searches by 6 experience levels for 6x more unique results |
| `maxJobsTotal` | integer | `0` | Global job limit (0 = unlimited) |
| `maxConcurrency` | integer | `3` | Parallel workers (1-10). Higher = faster, more proxy usage |
| `requestDelay` | integer | `1000` | Milliseconds between requests |
| `proxyConfiguration` | object | Residential | Proxy settings. **Residential proxies strongly recommended** |

### How It Works

1. **Combo Generation** — Builds all keyword × city × experience filter combinations
2. **Parallel Fetching** — Processes multiple combos simultaneously with configurable concurrency
3. **Data Extraction** — Parses Lagou's server-rendered JSON (`__NEXT_DATA__`) from each page
4. **Smart Retry** — Failed pages get 4 retries with fresh proxy IPs automatically
5. **Deduplication** — Position IDs track across all combos, ensuring zero duplicates
6. **Dataset Push** — Clean structured JSON pushed to Apify Dataset in real-time

### Scale & Performance

| Configuration | Combos | Est. Unique Jobs | Est. Time | Est. Cost |
|--------------|--------|-----------------|-----------|-----------|
| 2 keywords × 3 cities | 36 | 500-800 | 3-5 min | ~$0.15 |
| 5 keywords × 5 cities | 150 | 2,000-3,500 | 10-15 min | ~$0.50 |
| 10 keywords × 10 cities | 600 | 5,000-10,000 | 30-45 min | ~$2.00 |
| 20 keywords × 25 cities | 3,000 | 15,000-30,000 | 2-3 hours | ~$8.00 |

*Costs include Apify platform + residential proxy usage. Actual unique counts depend on job market overlap between keywords.*

### Keyword Ideas for Maximum Coverage

**Programming Languages:** Python, Java, JavaScript, TypeScript, Go, Rust, C++, PHP, Swift, Kotlin, Scala, Ruby

**Frameworks & Tools:** React, Vue, Angular, Spring, Django, Flask, Node.js, Docker, Kubernetes, Spark, Hadoop, TensorFlow, PyTorch

**Roles:** 前端 (Frontend), 后端 (Backend), 全栈 (Fullstack), 算法 (Algorithm), 数据 (Data), 产品经理 (Product Manager), 测试 (QA), 运维 (DevOps), 架构师 (Architect)

**Domains:** AI, 机器学习 (Machine Learning), 大数据 (Big Data), 云计算 (Cloud), 区块链 (Blockchain), 物联网 (IoT), 自动驾驶 (Autonomous Driving)

### Integration & Export

Output is available in all Apify-supported formats:

- **JSON / CSV / Excel** — Direct download from Apify Console
- **API** — RESTful access to dataset via Apify API
- **Webhook** — Trigger downstream pipelines on completion
- **Google Sheets** — Auto-sync with Google Sheets integration
- **Amazon S3 / Google Cloud** — Push to cloud storage
- **Zapier / Make** — Connect to 5,000+ apps
- **Custom** — Use Apify SDK in Python, JavaScript, or any HTTP client

### Frequently Asked Questions

**Q: Why only ~45 jobs per keyword+city combination?**
Lagou's platform limits search results to 3 pages (45 jobs) per query. The scraper compensates by using experience filter expansion, which creates 6 separate searches per keyword+city — each returning different job sets. This is why `expandFilters: true` is recommended.

**Q: Do I need residential proxies?**
Yes, strongly recommended. Lagou is a Chinese platform and may block datacenter IP ranges. Apify's residential proxy group provides reliable access.

**Q: Can I use Chinese keywords?**
Absolutely. Both English (`Python`) and Chinese (`Python开发工程师`, `前端工程师`, `算法`) keywords work. Chinese keywords often surface different results.

**Q: How often should I run this?**
Job listings on Lagou refresh frequently. For market monitoring, weekly runs are ideal. For comprehensive datasets, monthly runs with broad keyword coverage work well.

**Q: Is this legal?**
This scraper accesses only publicly available job listing data displayed on Lagou.com. No login, authentication, or private data is accessed. Please review Lagou's terms of service and your local regulations regarding web scraping.

### Changelog

- **v1.0** — Initial release. HTML + **NEXT\_DATA** extraction, parallel processing, experience filter expansion, 25+ city support, salary parsing, smart deduplication.

### Support

Found a bug or need a custom feature? Open an issue on this actor's page or contact the developer directly through Apify Console.

***

*Built for researchers, recruiters, analysts, and developers who need structured Chinese tech job market data at scale.*

# Actor input Schema

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

Job search keywords. More keywords = more unique results. Try: Python, Java, React, Go, AI, etc.

## `cities` (type: `array`):

City names (Chinese or English). More cities = more results. Leave empty for Beijing only.

## `expandFilters` (type: `boolean`):

Multiply searches by experience levels (6x more combos). Gets different job sets per filter. Highly recommended for maximum data.

## `maxJobsTotal` (type: `integer`):

Global limit on total jobs to collect. 0 = unlimited.

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

Parallel combo processing. Higher = faster but more proxy usage.

## `proxyConfiguration` (type: `object`):

Residential proxies recommended.

## `requestDelay` (type: `integer`):

Delay between requests.

## Actor input object example

```json
{
  "keywords": [
    "Python",
    "Java"
  ],
  "cities": [
    "beijing",
    "shanghai",
    "shenzhen"
  ],
  "expandFilters": true,
  "maxJobsTotal": 0,
  "maxConcurrency": 3,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  },
  "requestDelay": 1000
}
```

# Actor output Schema

## `jobTitle` (type: `string`):

No description

## `jobUrl` (type: `string`):

No description

## `companyName` (type: `string`):

No description

## `companyShortName` (type: `string`):

No description

## `companyUrl` (type: `string`):

No description

## `salary` (type: `string`):

No description

## `salaryMin` (type: `string`):

No description

## `salaryMax` (type: `string`):

No description

## `city` (type: `string`):

No description

## `district` (type: `string`):

No description

## `workYear` (type: `string`):

No description

## `education` (type: `string`):

No description

## `jobNature` (type: `string`):

No description

## `jobType` (type: `string`):

No description

## `skills` (type: `string`):

No description

## `companySize` (type: `string`):

No description

## `industryField` (type: `string`):

No description

## `financeStage` (type: `string`):

No description

## `companyLogo` (type: `string`):

No description

## `jobDescription` (type: `string`):

No description

## `publishTime` (type: `string`):

No description

## `positionId` (type: `string`):

No description

## `companyId` (type: `string`):

No description

## `searchKeyword` (type: `string`):

No description

## `searchCity` (type: `string`):

No description

## `pageNumber` (type: `string`):

No description

## `scrapedAt` (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": [
        "Python",
        "Java"
    ],
    "cities": [
        "beijing",
        "shanghai",
        "shenzhen"
    ],
    "expandFilters": true,
    "maxJobsTotal": 0,
    "maxConcurrency": 3,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    },
    "requestDelay": 1000
};

// Run the Actor and wait for it to finish
const run = await client.actor("logiover/lagou-tech-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 = {
    "keywords": [
        "Python",
        "Java",
    ],
    "cities": [
        "beijing",
        "shanghai",
        "shenzhen",
    ],
    "expandFilters": True,
    "maxJobsTotal": 0,
    "maxConcurrency": 3,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
    "requestDelay": 1000,
}

# Run the Actor and wait for it to finish
run = client.actor("logiover/lagou-tech-jobs-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "keywords": [
    "Python",
    "Java"
  ],
  "cities": [
    "beijing",
    "shanghai",
    "shenzhen"
  ],
  "expandFilters": true,
  "maxJobsTotal": 0,
  "maxConcurrency": 3,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  },
  "requestDelay": 1000
}' |
apify call logiover/lagou-tech-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Lagou Tech Jobs Scraper (拉勾网)",
        "description": "Extract thousands of tech job listings from Lagou.com (拉勾网), China's largest IT recruitment platform. Scrape salary ranges, tech stacks, company details, funding stages, and more from ByteDance, Alibaba, Tencent, Baidu, and 100,000+ Chinese tech companies. No browser needed — fast, cheap, scalable.",
        "version": "0.0",
        "x-build-id": "siygw3I2l1yW58dxQ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/logiover~lagou-tech-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-logiover-lagou-tech-jobs-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/logiover~lagou-tech-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-logiover-lagou-tech-jobs-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/logiover~lagou-tech-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-logiover-lagou-tech-jobs-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": "Search Keywords",
                        "type": "array",
                        "description": "Job search keywords. More keywords = more unique results. Try: Python, Java, React, Go, AI, etc.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "cities": {
                        "title": "Cities",
                        "type": "array",
                        "description": "City names (Chinese or English). More cities = more results. Leave empty for Beijing only.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "expandFilters": {
                        "title": "Expand with Experience Filters",
                        "type": "boolean",
                        "description": "Multiply searches by experience levels (6x more combos). Gets different job sets per filter. Highly recommended for maximum data.",
                        "default": true
                    },
                    "maxJobsTotal": {
                        "title": "Max Jobs Total",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Global limit on total jobs to collect. 0 = unlimited.",
                        "default": 0
                    },
                    "maxConcurrency": {
                        "title": "Concurrency",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Parallel combo processing. Higher = faster but more proxy usage.",
                        "default": 3
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Residential proxies recommended."
                    },
                    "requestDelay": {
                        "title": "Request Delay (ms)",
                        "minimum": 300,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Delay between requests.",
                        "default": 1000
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
