# Zhaopin Jobs Scraper - Low-cost💲🔥🇨🇳💼 (`delectable_incubator/zhaopin-jobs-scraper-low-cost`) Actor
🔍 Easily scrape jobs from Zhaopin (智联招聘). Extract job titles, companies, locations, salaries, experience, education, job types, posting dates, descriptions, company details, application URLs & more. Ideal for recruitment, HR analytics, China job market research and hiring intelligence.
- **URL**: https://apify.com/delectable\_incubator/zhaopin-jobs-scraper-low-cost.md
- **Developed by:** [Prime Scrape](https://apify.com/delectable_incubator) (community)
- **Categories:** Jobs, Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet
## Pricing
from $0.00005 / actor start
This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".
## How to integrate an Actor?
If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.
In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):
```bash
npm install apify-client
```
In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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
---
## 🇨🇳🌏💼 Zhaopin Jobs Scraper | 智联招聘职位采集器 | Bulk Job Scraper | Apify Actor
### 🚀 Extract Zhaopin Jobs Data in Seconds (No Code) | 快速采集智联招聘职位数据
The **Zhaopin Jobs Scraper (Apify Actor)** is a powerful, scalable and easy-to-use job scraping tool designed to extract structured job listings directly from **Zhaopin (智联招聘)**, one of the largest and most trusted recruitment platforms in China.
It allows you to scrape job listings in bulk using multiple keywords, including Chinese keywords, filter positions by employment type, automatically handle pagination, and export clean structured job data for recruitment, HR analytics, labor market research, salary analysis, job aggregation, AI datasets, and hiring intelligence.
---
### 🔥 Why This Zhaopin Jobs Scraper? | 为什么选择智联招聘职位采集器？
✔ Powerful Zhaopin job scraper on Apify
✔ Supports **Bulk Keyword Scraping**
✔ Supports Chinese keywords / 支持中文关键词
✔ Search multiple job keywords in a single run
✔ Supports full-time, part-time, internship and campus recruitment
✔ 支持全职、兼职、实习、校招
✔ Automatic pagination handling
✔ Extract salary, location, experience and education
✔ Extract company information and industry
✔ Extract recruiter information
✔ Extract recruiter status
✔ Extract company size and company type
✔ Control maximum jobs collected
✔ Clean structured dataset output
✔ Perfect for Chinese job market research
✔ Ideal for recruiters and HR teams
✔ Useful for salary and labor market analysis
✔ No coding required
---
### 🎯 What This Scraper Does (Zhaopin Job Data Extraction) | 功能介绍
This Apify Actor extracts structured job listings directly from Zhaopin search results.
#### 📌 Core Features | 核心功能:
✅ Scrape Zhaopin (智联招聘) job listings
✅ **Bulk keyword scraping support / 支持批量关键词采集**
✅ Search multiple keywords in one run / 支持多个关键词同时搜索
✅ Chinese keyword support / 支持中文关键词
✅ Finance, technology, sales, marketing and other job searches
✅ Employment type filtering / 职位类型筛选
✅ Full-time / 全职
✅ Part-time / 兼职
✅ Internship / 实习
✅ Campus recruitment / 校招
✅ Automatic pagination handling / 自动翻页
✅ Extract job titles / 提取职位名称
✅ Extract salary information / 提取薪资信息
✅ Extract job locations / 提取工作地点
✅ Extract experience requirements / 提取经验要求
✅ Extract education requirements / 提取学历要求
✅ Extract company names / 提取公司名称
✅ Extract company industry / 提取公司行业
✅ Extract company type / 提取公司类型
✅ Extract company size / 提取公司规模
✅ Extract recruiter information / 提取招聘人员信息
✅ Extract recruiter status / 提取招聘人员状态
✅ Extract company URLs / 提取公司页面
✅ Extract direct job URLs / 提取职位链接
✅ Control maximum jobs collected / 控制最大职位数量
✅ Clean structured dataset output / 输出结构化数据
---
### ⚡ Input Configuration (Simple & Powerful) | 输入配置
#### 🔥 BULK KEYWORD MODE 🚀 | 批量关键词模式
Scrape multiple Zhaopin job keywords in a single run.
在一次运行中同时搜索多个职位关键词。
````
{
"keywords": \[
"java开发工程师",
"python开发",
"数据分析",
"人工智能",
"产品经理",
"软件工程师",
"金融分析师",
"市场营销",
"销售经理",
"人力资源"
],
"position\_type": "full-time",
"max\_items": 100
}
````
#### 💡 Example Bulk Keywords | 批量关键词示例
You can search multiple Chinese and English job keywords simultaneously.
您可以同时搜索多个中文和英文职位关键词：
```text
java开发工程师
python开发
数据分析
人工智能
产品经理
软件工程师
金融分析师
市场营销
销售经理
人力资源
````
The scraper automatically processes each keyword and collects matching Zhaopin job listings.
采集器会自动处理每个关键词并收集对应的职位信息。
***
### 💼 Position Type Filtering | 职位类型筛选
Filter jobs by employment type.
根据职位类型筛选招聘信息。
Supported position types include:
```
full-time
part-time
internship
campus
```
对应：
```
全职
兼职
实习
校招
```
***
### 📊 Extracted Job Data (Structured Output) | 采集字段说明
#### 🔹 Job Overview | 总览
| Field | Description |
| -------------------- | -------------------------- |
| 🆔 `jobId` | Job ID / 职位ID |
| 🏷️ `jobTitle` | Job title / 职位名称 |
| 💰 `salary` | Salary range / 薪资 |
| 📍 `location` | Job location / 工作地点 |
| 📈 `experience` | Experience required / 经验要求 |
| 🎓 `education` | Education required / 学历要求 |
| 🏢 `companyName` | Company name / 公司名称 |
| 🏭 `companyIndustry` | Company industry / 公司行业 |
| 🔗 `jobUrl` | Job URL / 职位链接 |
***
#### 🔹 Detailed Job Information | 职位详细信息
| Field | Description |
| -------------------- | ------------------------- |
| 🆔 `jobId` | Job ID / 职位ID |
| 🏷️ `jobTitle` | Job title / 职位名称 |
| 💰 `salary` | Salary / 薪资 |
| 🏷️ `tags` | Skills / 技能标签 |
| 📍 `location` | Location / 工作地点 |
| 📈 `experience` | Experience / 经验要求 |
| 🎓 `education` | Education / 学历要求 |
| 🏢 `companyName` | Company name / 公司名称 |
| 🏷️ `companyType` | Company type / 公司类型 |
| 👥 `companySize` | Company size / 公司规模 |
| 🏭 `companyIndustry` | Industry / 行业 |
| 👤 `recruiterName` | Recruiter name / 招聘人员姓名 |
| 🟢 `recruiterStatus` | Recruiter status / 招聘人员状态 |
| 🔗 `jobUrl` | Job URL / 职位链接 |
| 🏢 `companyUrl` | Company page / 公司页面 |
***
### 📦 Example Output | 输出示例
```
{
"jobId": "CCL1486913460J40801488601",
"jobTitle": "Java后端开发工程师",
"jobUrl": "http://www.zhaopin.com/jobdetail/CCL1486913460J40801488601.htm?refcode=4019&srccode=401903&preactionid=8e78dd15-352d-4c65-93cb-9c4babd86c8b",
"salary": "1.1-1.9万",
"location": "扬州·邗江区·蒋王街道",
"companyName": "扬州唐梦网络科技合伙企业(有限合伙)"
}
```
***
### 💡 Use Cases (High-Demand Job Data Research) | 使用场景
This Zhaopin Jobs Scraper is useful for:
💼 Job aggregation platforms / 招聘聚合平台
📊 Chinese labor market analysis / 中国劳动力市场分析
💰 Salary analysis and benchmarking / 薪资分析
🎯 Recruitment and talent sourcing / 招聘与人才搜寻
🏢 Company hiring intelligence / 企业招聘情报
📈 Hiring trends and industry research / 招聘趋势与行业研究
🤖 AI and NLP training datasets / AI 与 NLP 训练数据
🔍 Job market monitoring / 招聘市场监测
⚡ Bulk job data extraction / 批量职位数据采集
***
### 🚀 Key Features (Apify SEO Optimized)
⚡ **Bulk keyword scraping support / 批量关键词采集**
🇨🇳 Chinese job market coverage / 中国招聘市场覆盖
🔍 Multiple keyword searches / 多关键词搜索
💼 Employment type filtering / 职位类型筛选
📌 Automatic pagination system / 自动翻页
💰 Salary information extraction / 薪资信息提取
📍 Location extraction / 工作地点提取
📈 Experience and education extraction / 经验和学历提取
🏢 Company information extraction / 公司信息提取
👤 Recruiter information extraction / 招聘人员信息提取
🏷️ Job skills and tags extraction / 技能标签提取
🎯 Maximum jobs control / 最大职位数量控制
🧠 Clean structured output / 结构化数据输出
📊 Preconfigured dataset views / 预配置数据视图
💾 Export-ready datasets / 可导出数据集
⚙️ Scalable cloud execution with Apify / Apify 云端执行
***
### 🛠️ How to Use | 使用方法
#### 1️⃣ Deploy the Actor on Apify
Run the **Zhaopin Jobs Scraper** from the Apify platform.
在 Apify 平台运行 **Zhaopin Jobs Scraper**。
#### 2️⃣ Add Multiple Job Keywords | 输入多个职位关键词
Use **Bulk Keyword Mode** to search for multiple positions in a single run.
使用 **Bulk Keyword Mode** 在一次运行中搜索多个职位。
Example:
```
{
"keywords": [
"java开发工程师",
"python开发",
"数据分析",
"人工智能"
],
"position_type": "full-time",
"max_items": 100
}
```
#### 3️⃣ Select Position Type | 选择职位类型
Choose the desired employment type:
```
full-time
part-time
internship
campus
```
对应：
```
全职
兼职
实习
校招
```
#### 4️⃣ Set the Maximum Number of Jobs | 设置最大职位数量
Define the maximum number of jobs to collect.
设置需要采集的最大职位数量。
Example:
```
100
```
#### 5️⃣ Run the Scraper | 运行采集器
Launch the Actor and it will automatically process the provided keywords, apply the selected position type, handle pagination, and collect structured job data.
启动 Actor 后，采集器将自动处理关键词、应用职位类型筛选、自动翻页并收集结构化职位数据。
#### 6️⃣ Export Your Data | 导出数据
Download your structured dataset in:
- JSON
- CSV
- Excel XLSX
- XML
- HTML
***
### 📊 Input Fields | 输入字段
| Field | Type | Description |
| --------------- | ------- | ---------------------------------------- |
| `keywords` | array | Multiple job search keywords / 多个职位搜索关键词 |
| `position_type` | string | Employment type / 职位类型 |
| `max_items` | integer | Maximum number of jobs / 最大职位数量 |
***
### 📊 Preconfigured Dataset Views | 内置数据视图
#### 📋 Overview View | 总览
Quick overview of collected job listings.
快速查看采集的职位列表。
Includes:
- Job ID / 职位ID
- Job Title / 职位名称
- Salary / 薪资
- Location / 工作地点
- Experience / 经验
- Education / 学历
- Company Name / 公司名称
- Company Industry / 公司行业
- Job URL / 职位链接
#### 🔍 Detailed Job Information | 详细职位信息
Complete job and recruiter information.
完整的职位和招聘人员信息。
Includes:
- Job ID
- Job Title
- Salary
- Tags
- Location
- Experience
- Education
- Company Name
- Company Type
- Company Size
- Company Industry
- Recruiter Name
- Recruiter Status
- Job URL
- Company URL
#### 🏢 Company Information | 公司信息
Identify companies hiring on Zhaopin.
了解正在智联招聘发布职位的企业信息。
Includes:
- Company Name
- Company Type
- Company Size
- Company Industry
- Company URL
#### 💰 Salary Overview | 薪资分析
Analyze available salary information across collected job listings.
分析采集职位中的薪资信息。
Includes:
- Job Title
- Salary
- Location
- Experience
- Education
- Company Name
***
### 🔥 Why Use This Zhaopin Jobs Scraper?
✔ Search multiple Chinese job keywords in one run
✔ Bulk keyword scraping for large-scale job research
✔ Collect Chinese job market data efficiently
✔ Filter full-time, part-time, internship and campus jobs
✔ Analyze salary ranges and job requirements
✔ Identify companies actively hiring
✔ Research Chinese labor market trends
✔ Extract recruiter and company information
✔ Build structured AI and NLP job datasets
✔ Create job aggregation datasets
✔ Automate recruitment data collection
✔ No coding required
***
### 💸 Pricing
This scraper runs on a **pay-per-result pricing model**.
You only pay for successfully extracted records.
💳 **Price:** **$1.39 / 1,000 results**
***
### ❓ FAQ (SEO BOOST SECTION)
#### Can I scrape multiple keywords at once?
Yes. The scraper supports **Bulk Keyword Scraping**, allowing you to search multiple Chinese or English job keywords in a single run.
#### Can I use Chinese keywords?
Yes. Chinese keywords are fully supported.
Examples:
```
java开发工程师
python开发
数据分析
人工智能
产品经理
```
#### Can I filter by employment type?
Yes. You can filter positions by:
```
全职
兼职
实习
校招
```
#### Does the scraper handle pagination?
Yes. The Actor automatically handles pagination to collect available job listings from Zhaopin search results.
#### What job data can I extract?
You can extract job IDs, job titles, salaries, locations, experience requirements, education requirements, tags, company information, recruiter information, job URLs, and company URLs.
#### Can I export the results?
Yes. The extracted dataset can be exported in JSON, CSV, Excel XLSX, XML, and HTML formats.
#### Is coding required?
No. The Zhaopin Jobs Scraper runs as a no-code Apify Actor.
***
### 🌍 PrimeScrape Job Intelligence Ecosystem
The **PrimeScrape Job Intelligence Suite** is built for large-scale job data extraction, recruitment automation, labor market research, and hiring intelligence.
💼 Job data extraction
🇨🇳 Chinese job market intelligence
🎯 Recruitment and talent sourcing
🏢 Company hiring intelligence
📊 Labor market analytics
💰 Salary benchmarking
📈 Hiring trend analysis
🤖 AI and NLP datasets
⚙️ Recruitment automation pipelines
🌍 Global job market intelligence
***
### 🔗 Related Actors (PrimeScrape Ecosystem)
We are building a complete **PrimeScrape Data Intelligence Suite** for automated web data extraction, jobs, companies, e-commerce, automotive data, social media, AI datasets, and market intelligence.
👉 More scraping tools coming soon 🚀
***
### ⚠️ Disclaimer
This scraper is an independent automation and data extraction tool.
It is **not affiliated with, endorsed by, or sponsored by Zhaopin (智联招聘)**.
Users are responsible for ensuring that their use of the scraper complies with all applicable laws, regulations, and the terms of service of the websites they access.
***
### 📬 Support
⭐⭐⭐⭐⭐ Leave a 5-star review if you like this scraper!
📩 Contact us for custom scraping solutions, feature requests, or enterprise scraping projects.
🚀 **PrimeScrape — Data extraction and automation at scale.**
# Actor input Schema
## `keywords` (type: `array`):
List of keywords to search for; one independent search is run per keyword (e.g., 'python', 'java', '数据分析'). Add multiple entries for a bulk run.
## `position_type` (type: `string`):
Type of employment position, applied to every keyword search / 职位雇佣类型
## `max_items` (type: `integer`):
Limits how many job listings will be scraped for EACH keyword in the list / 限制每个关键词采集的职位数量
## `proxy` (type: `object`):
RESIDENTIAL proxy required
## Actor input object example
```json
{
"keywords": [
"java"
],
"position_type": "any",
"max_items": 100,
"proxy": {
"useApifyProxy": true,
"apifyProxyGroups": [
"RESIDENTIAL"
],
"apifyProxyCountry": "CN"
}
}
```
# 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 '' with your token
const client = new ApifyClient({
token: '',
});
// Prepare Actor input
const input = {
"keywords": [
"java"
],
"position_type": "any",
"max_items": 100,
"proxy": {
"useApifyProxy": true,
"apifyProxyGroups": [
"RESIDENTIAL"
],
"apifyProxyCountry": "CN"
}
};
// Run the Actor and wait for it to finish
const run = await client.actor("delectable_incubator/zhaopin-jobs-scraper-low-cost").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 '' with your token.
client = ApifyClient("")
# Prepare the Actor input
run_input = {
"keywords": ["java"],
"position_type": "any",
"max_items": 100,
"proxy": {
"useApifyProxy": True,
"apifyProxyGroups": ["RESIDENTIAL"],
"apifyProxyCountry": "CN",
},
}
# Run the Actor and wait for it to finish
run = client.actor("delectable_incubator/zhaopin-jobs-scraper-low-cost").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": [
"java"
],
"position_type": "any",
"max_items": 100,
"proxy": {
"useApifyProxy": true,
"apifyProxyGroups": [
"RESIDENTIAL"
],
"apifyProxyCountry": "CN"
}
}' |
apify call delectable_incubator/zhaopin-jobs-scraper-low-cost --silent --output-dataset
```
## MCP server setup
```json
{
"mcpServers": {
"apify": {
"command": "npx",
"args": [
"mcp-remote",
"https://mcp.apify.com/?tools=delectable_incubator/zhaopin-jobs-scraper-low-cost",
"--header",
"Authorization: Bearer "
]
}
}
}
```
## OpenAPI specification
```json
{
"openapi": "3.0.1",
"info": {
"title": "Zhaopin Jobs Scraper - Low-cost💲🔥🇨🇳💼",
"description": "🔍 Easily scrape jobs from Zhaopin (智联招聘). Extract job titles, companies, locations, salaries, experience, education, job types, posting dates, descriptions, company details, application URLs & more. Ideal for recruitment, HR analytics, China job market research and hiring intelligence.",
"version": "0.0",
"x-build-id": "NBxKai4QySWh43VMt"
},
"servers": [
{
"url": "https://api.apify.com/v2"
}
],
"paths": {
"/acts/delectable_incubator~zhaopin-jobs-scraper-low-cost/run-sync-get-dataset-items": {
"post": {
"operationId": "run-sync-get-dataset-items-delectable_incubator-zhaopin-jobs-scraper-low-cost",
"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/delectable_incubator~zhaopin-jobs-scraper-low-cost/runs": {
"post": {
"operationId": "runs-sync-delectable_incubator-zhaopin-jobs-scraper-low-cost",
"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/delectable_incubator~zhaopin-jobs-scraper-low-cost/run-sync": {
"post": {
"operationId": "run-sync-delectable_incubator-zhaopin-jobs-scraper-low-cost",
"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",
"position_type",
"proxy"
],
"properties": {
"keywords": {
"title": "Search Keywords / 搜索关键词 🔍",
"type": "array",
"description": "List of keywords to search for; one independent search is run per keyword (e.g., 'python', 'java', '数据分析'). Add multiple entries for a bulk run.",
"default": [
"java"
],
"items": {
"type": "string"
}
},
"position_type": {
"title": "Position Type / 职位类型 💼",
"enum": [
"any",
"full-time",
"part-time",
"internships",
"campus"
],
"type": "string",
"description": "Type of employment position, applied to every keyword search / 职位雇佣类型",
"default": "any"
},
"max_items": {
"title": "Maximum number of jobs per keyword / 每个关键词最大采集职位数 🔢",
"type": "integer",
"description": "Limits how many job listings will be scraped for EACH keyword in the list / 限制每个关键词采集的职位数量",
"default": 100
},
"proxy": {
"title": "Proxy Configuration",
"type": "object",
"description": "RESIDENTIAL proxy required",
"default": {
"useApifyProxy": true,
"apifyProxyGroups": [
"RESIDENTIAL"
],
"apifyProxyCountry": "CN"
}
}
}
},
"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
}
}
}
}
}
}
}
}
}
}
```