# 51job Scraper (`automation-lab/51job-scraper`) Actor

Scrape 51job jobs with salary, company, location, requirements, descriptions, tags, and URLs for China hiring intelligence.

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

## Pricing

from $0.11 / 1,000 job posting saveds

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

## 51job Scraper

Extract public job postings from 51job (前程无忧) for China recruiting, staffing, HR-tech, and labor-market analysis workflows.

The actor searches `we.51job.com`, captures the public job-search response, and saves structured job records with company, salary, location, requirements, tags, descriptions, recruiter signals, and source URLs.

### What does 51job Scraper do?

51job Scraper turns 51job search pages into a clean Apify dataset.

It can:

- 🔎 Search 51job by keyword.
- 🌏 Limit results to a 51job area code such as Shanghai or nationwide.
- 🧾 Extract job titles, employers, salaries, locations, and requirements.
- 🧩 Include long job descriptions when available.
- 🏢 Capture company size, company type, and company industry.
- 📍 Save province, city, district, and coordinates when 51job returns them.
- 🔗 Keep job and company URLs for verification or enrichment.

### Who is it for?

Recruiters use it to monitor competing employers and active hiring signals.

Staffing agencies use it to build lead lists and identify companies with urgent demand.

HR-tech teams use it to power job-market dashboards, compensation studies, and talent-supply workflows.

Labor-market analysts use it to track demand by city, function, industry, and job family across China.

### Why use this actor?

51job is a major China job-board source, but the modern search page is a dynamic SPA with anti-bot challenge behavior. This actor uses a browser session and captures the site's public search JSON after the page loads.

You get a dataset that is ready for spreadsheets, BI tools, CRMs, or downstream enrichment.

### Typical use cases

- Track salary ranges for a role in Shanghai, Beijing, Guangzhou, or Shenzhen.
- Monitor which companies are hiring for a keyword such as `python`, `数据分析`, or `销售`.
- Build recruiter lead lists from companies posting new jobs.
- Compare demand by city or job function.
- Feed a labor-market dashboard with current postings.
- Collect job descriptions for skill-frequency analysis.

### Input options

The actor supports two ways to define searches.

Use `keywords` for simple searches.

Use `startUrls` when you copied a search URL from 51job and want the actor to parse its query parameters.

### Keywords

Add one or more search terms in the `keywords` field.

Examples:

- `python`
- `数据分析`
- `销售`
- `Java`
- `项目经理`

Each keyword creates a separate search target.

### Job area codes

Use `jobArea` to target a 51job region.

Common examples:

- `000000` — nationwide
- `010000` — Beijing
- `020000` — Shanghai
- `030200` — Guangzhou
- `040000` — Shenzhen

If you are unsure, copy a 51job search URL into `startUrls`; the actor will parse the area code from the URL when present.

### Limits and pagination

`maxItems` controls the total number of job records saved.

`maxPages` controls how many search pages are loaded for each keyword or start URL.

`pageSize` controls how many records 51job should return per page.

Start small, verify the dataset, and then increase limits for monitoring jobs.

### Output data

Each dataset item represents one public 51job job posting.

The actor saves practical fields for analysis and verification.

### Output table

| Field | Description |
| --- | --- |
| `jobId` | 51job job identifier |
| `jobName` | Job title |
| `companyName` | Display company name |
| `fullCompanyName` | Full legal/display company name when available |
| `salary` | Salary text from 51job |
| `salaryMin` / `salaryMax` | Parsed salary bounds when provided by 51job |
| `location` | Human-readable job location |
| `province`, `city`, `district` | Location breakdown |
| `workYear` | Experience requirement |
| `degree` | Education requirement |
| `jobType` | Full-time, part-time, internship, etc. |
| `industry` | Job industry |
| `companyType` | Company ownership/type |
| `companySize` | Company size bucket |
| `issueDate` | Posting date/time |
| `updateDateTime` | Last update timestamp |
| `jobTags` | Skills, benefits, and requirement tags |
| `jobDescription` | Long job description when enabled |
| `jobUrl` | Public job URL |
| `companyUrl` | Public company URL |
| `searchKeyword` | Keyword that produced the item |
| `sourceUrl` | 51job search URL used for the page |
| `scrapedAt` | Actor scrape timestamp |

### Example input

```json
{
  "keywords": ["python"],
  "jobArea": "020000",
  "maxItems": 50,
  "maxPages": 3,
  "pageSize": 20,
  "includeDescriptions": true
}
````

### Example output

```json
{
  "jobId": "172765694",
  "jobName": "中级大数据开发工程师",
  "companyName": "上海海隆软件",
  "salary": "1-1.6万",
  "location": "上海·徐汇区",
  "workYear": "3年及以上",
  "degree": "本科",
  "jobTags": ["sql", "报表", "五险一金"],
  "jobUrl": "https://jobs.51job.com/shanghai-xhq/172765694.html",
  "searchKeyword": "python"
}
```

### How much does it cost to scrape 51job jobs?

This actor uses pay-per-event pricing.

You pay a small run start fee plus a per-job fee for each job posting saved to the dataset.

The final price shown on Apify is authoritative. Use low `maxItems` values for test runs, then scale after you confirm the dataset shape.

### How to run it

1. Open the actor on Apify.
2. Add one or more keywords.
3. Choose a 51job area code or leave `000000` for nationwide.
4. Set `maxItems` to a small number for your first run.
5. Start the actor.
6. Download the dataset as JSON, CSV, Excel, or via API.

### Tips for better results

Use Chinese role names when your workflow is China-focused.

Use city-specific area codes for local compensation research.

Disable `includeDescriptions` if you only need high-level listing fields and want smaller dataset rows.

Use multiple short runs for recurring monitoring rather than one very large exploratory run.

### Integrations

Send the dataset to Google Sheets for recruiter review.

Load the JSON into a data warehouse for trend analysis.

Push company URLs into an enrichment workflow.

Use Apify webhooks to trigger a Slack alert when a search finishes.

Use the Apify API to schedule recurring searches for the same keywords.

### API usage

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/51job-scraper').call({
  keywords: ['python'],
  jobArea: '020000',
  maxItems: 50
});
console.log(run.defaultDatasetId);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient(token='YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/51job-scraper').call(run_input={
    'keywords': ['python'],
    'jobArea': '020000',
    'maxItems': 50,
})
print(run['defaultDatasetId'])
```

#### cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~51job-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"keywords":["python"],"jobArea":"020000","maxItems":50}'
```

### MCP usage

Use this actor from Claude Desktop or Claude Code through Apify MCP.

MCP tool URL:

`https://mcp.apify.com/?tools=automation-lab/51job-scraper`

Claude Code setup:

```bash
claude mcp add apify https://mcp.apify.com/?tools=automation-lab/51job-scraper
```

Claude Desktop JSON setup:

```json
{
  "mcpServers": {
    "apify-51job": {
      "url": "https://mcp.apify.com/?tools=automation-lab/51job-scraper"
    }
  }
}
```

Example prompts:

- "Run 51job Scraper for python jobs in Shanghai and summarize top employers."
- "Extract 100 data analyst jobs from 51job nationwide and group them by salary range."
- "Monitor 51job postings for sales roles in Guangzhou and list companies hiring this week."

### Data quality notes

The actor returns fields made public by 51job's search page.

Some postings may omit salary, recruiter activity, exact district, or long descriptions.

Salary parsing depends on fields returned by 51job; always keep the original `salary` text for auditability.

### Troubleshooting

If a run returns zero items, check that the keyword has active postings on 51job.

If a city returns fewer jobs than expected, verify the `jobArea` code or use a copied `startUrls` value from the 51job UI.

If 51job changes its anti-bot or API behavior, the actor may need a maintenance update.

### Legality and ethical use

This actor extracts public job-search data. Use it responsibly, respect applicable laws, and avoid collecting or using data in ways that violate privacy, employment, or platform rules.

Do not use the data for spam, harassment, discriminatory profiling, or unauthorized credentialed access.

### Related scrapers

You may also want these automation-lab actors:

- https://apify.com/automation-lab/google-news-scraper
- https://apify.com/automation-lab/linktree-profile-scraper
- https://apify.com/automation-lab/website-contact-finder

### FAQ

#### Can I scrape nationwide jobs?

Yes. Set `jobArea` to `000000`.

#### Can I use a 51job URL instead of keywords?

Yes. Add the URL to `startUrls`. The actor parses supported query parameters.

#### Does the actor need a 51job account?

No. It uses public search pages and public search responses.

#### Does it scrape applicant resumes?

No. It only extracts public job posting data.

#### Can I monitor jobs every day?

Yes. Create an Apify task with the same input and schedule it.

#### Why are some fields missing?

51job does not return every field for every posting. Missing optional fields are omitted from the dataset item.

### Changelog

- `0.1` — Initial private build with keyword/search URL inputs and public job-posting extraction.

# Actor input Schema

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

Job keywords to search on 51job. Examples: python, 数据分析, 销售, project manager.

## `jobArea` (type: `string`):

51job area code. Use 000000 for nationwide, 010000 Beijing, 020000 Shanghai, 030200 Guangzhou, 040000 Shenzhen.

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

Optional full URLs from we.51job.com/pc/search. The actor parses keyword, jobArea, and sortType from the URL.

## `maxItems` (type: `integer`):

Maximum job posting records to save.

## `maxPages` (type: `integer`):

Maximum search-result pages to load for each keyword or start URL.

## `pageSize` (type: `integer`):

How many search results 51job should return per page.

## `sortType` (type: `string`):

51job sort mode. 0 = comprehensive, 1 = latest, 2 = salary, 3 = distance.

## `includeDescriptions` (type: `boolean`):

Save the long job description returned by 51job's public search API.

## Actor input object example

```json
{
  "keywords": [
    "python"
  ],
  "jobArea": "020000",
  "startUrls": [
    {
      "url": "https://we.51job.com/pc/search?keyword=python&searchType=2&jobArea=020000&sortType=0"
    }
  ],
  "maxItems": 20,
  "maxPages": 3,
  "pageSize": 20,
  "sortType": "0",
  "includeDescriptions": true
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "keywords": [
        "python"
    ],
    "jobArea": "020000",
    "startUrls": [
        {
            "url": "https://we.51job.com/pc/search?keyword=python&searchType=2&jobArea=020000&sortType=0"
        }
    ],
    "maxItems": 20,
    "maxPages": 3,
    "pageSize": 20,
    "sortType": "0",
    "includeDescriptions": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/51job-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"],
    "jobArea": "020000",
    "startUrls": [{ "url": "https://we.51job.com/pc/search?keyword=python&searchType=2&jobArea=020000&sortType=0" }],
    "maxItems": 20,
    "maxPages": 3,
    "pageSize": 20,
    "sortType": "0",
    "includeDescriptions": True,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/51job-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"
  ],
  "jobArea": "020000",
  "startUrls": [
    {
      "url": "https://we.51job.com/pc/search?keyword=python&searchType=2&jobArea=020000&sortType=0"
    }
  ],
  "maxItems": 20,
  "maxPages": 3,
  "pageSize": 20,
  "sortType": "0",
  "includeDescriptions": true
}' |
apify call automation-lab/51job-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "51job Scraper",
        "description": "Scrape 51job jobs with salary, company, location, requirements, descriptions, tags, and URLs for China hiring intelligence.",
        "version": "0.1",
        "x-build-id": "G8eIQi3yo3aYSEB4w"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~51job-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-51job-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/automation-lab~51job-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-51job-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/automation-lab~51job-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-51job-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",
                "properties": {
                    "keywords": {
                        "title": "Keywords",
                        "type": "array",
                        "description": "Job keywords to search on 51job. Examples: python, 数据分析, 销售, project manager.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "jobArea": {
                        "title": "Job area code",
                        "type": "string",
                        "description": "51job area code. Use 000000 for nationwide, 010000 Beijing, 020000 Shanghai, 030200 Guangzhou, 040000 Shenzhen.",
                        "default": "000000"
                    },
                    "startUrls": {
                        "title": "51job search URLs",
                        "type": "array",
                        "description": "Optional full URLs from we.51job.com/pc/search. The actor parses keyword, jobArea, and sortType from the URL.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum jobs",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum job posting records to save.",
                        "default": 20
                    },
                    "maxPages": {
                        "title": "Maximum pages per search",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Maximum search-result pages to load for each keyword or start URL.",
                        "default": 5
                    },
                    "pageSize": {
                        "title": "Page size",
                        "minimum": 10,
                        "maximum": 100,
                        "type": "integer",
                        "description": "How many search results 51job should return per page.",
                        "default": 20
                    },
                    "sortType": {
                        "title": "Sort type",
                        "enum": [
                            "0",
                            "1",
                            "2",
                            "3"
                        ],
                        "type": "string",
                        "description": "51job sort mode. 0 = comprehensive, 1 = latest, 2 = salary, 3 = distance.",
                        "default": "0"
                    },
                    "includeDescriptions": {
                        "title": "Include job descriptions",
                        "type": "boolean",
                        "description": "Save the long job description returned by 51job's public search API.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```