# Zhihu Article Scraper (`automation-lab/zhihu-article-scraper`) Actor

📝 Extract public Zhihu Zhuanlan articles by URL into clean text, Markdown and HTML, with authors, topics, images, timestamps, permissions and engagement metrics.

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

## Pricing

Pay per event

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

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

## What's an Apify Actor?

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

## Zhihu Article Scraper

Extract complete public Zhihu Zhuanlan articles from known URLs.

Turn long-form Chinese content into clean HTML, plain text, Markdown, author metadata, topics, images, timestamps, and engagement metrics—without maintaining a browser or a Zhihu account.

[Zhihu Article Scraper](https://apify.com/automation-lab/zhihu-article-scraper) is built for repeatable research, monitoring, localization, and LLM data pipelines.

### What does Zhihu Article Scraper do?

Give the Actor one or more public URLs such as:

`https://zhuanlan.zhihu.com/p/2055333119083992479`

For every valid article, the Actor:

- 📝 extracts the title, excerpt, and full article;
- 👤 captures author identity and profile metadata;
- 🏷️ normalizes topics and images;
- 📈 records votes, comments, favorites, and likes;
- 🕐 converts publication and update times to ISO timestamps;
- 🧹 returns sanitized HTML, readable text, and Markdown;
- 🔗 preserves both canonical and submitted source URLs.

The result is a structured dataset ready for JSON, CSV, Excel, XML, RSS, or API export.

### Who is it for?

#### Consumer intelligence teams

Track known Zhihu essays from brands, experts, and commentators.

Compare engagement and messaging over time.

#### Content and SEO researchers

Archive source articles and analyze topics, headings, links, and terminology.

Build repeatable content-gap or citation workflows.

#### Localization agencies

Export Chinese source text as Markdown or plain text for translation tools.

Keep author and source provenance beside each document.

#### LLM and RAG builders

Create structured document records for retrieval, classification, summarization, and embeddings.

Use `contentText` for simple pipelines or `contentMarkdown` when headings and links matter.

#### Social-listening operators

Schedule recurring runs for known public article URLs and send fresh snapshots downstream.

### Why use this Zhihu article extractor?

- **No browser maintenance:** extraction uses the public server-rendered article state.
- **No Zhihu credentials:** the supported route is anonymous.
- **Three content formats:** HTML, text, and Markdown are returned together.
- **Typed metadata:** authors, topics, dates, and counts use stable fields.
- **Low concurrency:** conservative defaults reduce rate-limit risk.
- **Fail-closed scope:** Q&A and profile URLs are rejected instead of producing misleading data.
- **Apify integrations:** connect datasets to webhooks, Make, Zapier, Google Sheets, or your own API.

### Supported pages and scope

Supported:

- public `zhuanlan.zhihu.com/p/{numeric-id}` article pages;
- one URL or batches of known article URLs;
- duplicate URL removal within a run.

Not supported in v1:

- Zhihu question or answer pages;
- keyword search;
- user profiles;
- hot lists;
- column listing and pagination;
- login-only, private, deleted, or restricted content.

This boundary keeps the product honest and predictable.

### What data can you extract?

| Field | Description |
|---|---|
| `articleId` | Numeric Zhihu article ID |
| `title` | Article title |
| `url` | Canonical article URL |
| `authorId` | Zhihu author identifier |
| `authorName` | Display name |
| `authorUrl` | Public author URL |
| `authorHeadline` | Author headline or description |
| `authorAvatarUrl` | Avatar image URL |
| `excerpt` | Article excerpt |
| `contentHtml` | Sanitized article HTML |
| `contentText` | Whitespace-normalized plain text |
| `contentMarkdown` | Markdown generated from the article body |
| `imageUrl` | Main article image |
| `images` | All discovered article image URLs |
| `topics` | Topic IDs, names, and URLs |
| `createdAt` | Publication time in ISO format |
| `updatedAt` | Last update time in ISO format |
| `voteupCount` | Vote count |
| `commentCount` | Comment count |
| `favoriteCount` | Favorite-list count |
| `likedCount` | Like count when exposed |
| `commentPermission` | Comment permission state |
| `copyrightPermission` | Copyright permission state |
| `state` | Source article state |
| `status` | Source article status |
| `isVisible` | Visibility flag when exposed |
| `canComment` | Whether comments are allowed |
| `ipLocation` | IP/location label when publicly exposed |
| `sourceUrl` | URL submitted by the user |
| `scrapedAt` | Extraction timestamp |

### How to scrape Zhihu articles

1. Open the Actor input page.
2. Paste one or more public Zhuanlan article URLs into **Zhihu article URLs**.
3. Keep **Maximum concurrency** at 2 or 3 for normal batches.
4. Set **Maximum articles** to your desired cap.
5. Leave proxy disabled unless direct requests are blocked from your region.
6. Click **Start**.
7. Export the dataset in your preferred format.

A prefilled one-article run is the cheapest way to validate your workflow.

### Input configuration

#### `startUrls`

Required list of public article pages.

Each URL must use `https://zhuanlan.zhihu.com/p/{numeric-id}`.

Tracking query strings and fragments are normalized away.

#### `maxItems`

Maximum unique article records to save.

The default is 10; the Store prefill uses 3 to keep first runs inexpensive.

#### `maxConcurrency`

Number of parallel article requests.

Allowed range: 1–5.

Use 1–3 for stable recurring jobs.

#### `proxyConfiguration`

Optional Apify Proxy or custom proxy URLs.

Direct HTTP is used when this setting is disabled.

### Example input

```json
{
  "startUrls": [
    { "url": "https://zhuanlan.zhihu.com/p/2055333119083992479" }
  ],
  "maxItems": 10,
  "maxConcurrency": 2,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
````

For recurring monitoring, keep the same URL list in an Apify Task and schedule it.

### Example output

```json
{
  "articleId": "2055333119083992479",
  "title": "2026“普通人”就业现状：这5大变化你要知道！",
  "url": "https://zhuanlan.zhihu.com/p/2055333119083992479",
  "authorName": "Example author",
  "excerpt": "A public article excerpt",
  "topics": [
    { "id": "19590199", "name": "就业", "url": "https://www.zhihu.com/api/v4/topics/19590199" }
  ],
  "voteupCount": 0,
  "commentCount": 0,
  "favoriteCount": 0,
  "contentText": "Complete normalized article text...",
  "contentMarkdown": "## Complete article...",
  "sourceUrl": "https://zhuanlan.zhihu.com/p/2055333119083992479",
  "scrapedAt": "2026-07-24T04:00:00.000Z"
}
```

Actual authors, content, counts, and dates come from the source page.

### How much does it cost to extract Zhihu articles?

The Actor uses pay-per-event pricing.

- **Run start:** $0.005 per run.
- **Article extracted:** BRONZE price $0.0005267 per saved article, with plan-based volume tiers.
- Failed URLs do not trigger the article event.
- Apify platform compute may apply according to your plan.

You can estimate a BRONZE run as `$0.005 + saved articles × $0.0005267`.

For example, 10 successfully extracted articles cost about $0.01027 before any plan-specific platform usage.

See the live pricing tab for the price applicable to your account tier.

### Reliability and retries

Every article request has a 30-second timeout and up to three bounded attempts.

HTTP 403, 429, and server errors trigger a retry.

When a proxy configuration is present, retries can use a fresh proxy session.

A mixed batch can save valid articles and log warnings for failed URLs.

If no complete article is extracted, the run fails instead of returning an empty success.

### Tips for stable recurring runs

- Keep concurrency low.
- Submit canonical Zhuanlan article URLs.
- Remove deleted or private URLs from long-lived tasks.
- Enable a proxy only after confirming direct access is blocked.
- Split very large URL inventories into scheduled batches.
- Monitor logs for new source-side restrictions.
- Store immutable historical snapshots in a named dataset or external warehouse.

### Export and integrations

#### Google Sheets

Use an Apify integration to append new article records to a research sheet.

Select `title`, `authorName`, `topics`, `createdAt`, counts, and `url` for a compact view.

#### Make and Zapier

Trigger a scenario when a run succeeds.

Send Markdown to translation, summarization, or editorial-review steps.

#### Webhooks

Attach a run-succeeded webhook and fetch dataset items from your backend.

This works well for scheduled watchlists.

#### Data warehouses

Export JSON or CSV to object storage, BigQuery, Snowflake, or a relational database.

Use `articleId` as the source identity and `scrapedAt` as the snapshot time.

### API usage with JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/zhihu-article-scraper').call({
  startUrls: [
    { url: 'https://zhuanlan.zhihu.com/p/2055333119083992479' }
  ],
  maxItems: 10,
  maxConcurrency: 2
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("automation-lab/zhihu-article-scraper").call(run_input={
    "startUrls": [
        {"url": "https://zhuanlan.zhihu.com/p/2055333119083992479"}
    ],
    "maxItems": 10,
    "maxConcurrency": 2,
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

### API usage with cURL

```bash
curl -X POST \
  'https://api.apify.com/v2/acts/automation-lab~zhihu-article-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{
    "startUrls": [{"url":"https://zhuanlan.zhihu.com/p/2055333119083992479"}],
    "maxItems": 10,
    "maxConcurrency": 2
  }'
```

Poll the returned run ID, then read its default dataset.

### Use with Apify MCP

Connect the Actor to Claude Code or another MCP client through Apify MCP.

#### Claude Code

```bash
claude mcp add --transport http apify "https://mcp.apify.com/?tools=automation-lab/zhihu-article-scraper"
```

#### Claude Desktop

Add this remote server in **Settings → Developer → Edit Config**:

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

#### Cursor

Open **Settings → Tools & Integrations → MCP**, add a remote HTTP server, and use:

`https://mcp.apify.com/?tools=automation-lab/zhihu-article-scraper`

#### VS Code

Open the Command Palette, choose **MCP: Add Server**, select **HTTP**, and enter the same Apify MCP URL.

Example prompts:

- “Extract these three Zhihu articles and summarize their shared themes.”
- “Return Markdown and author metadata for this Zhuanlan URL.”
- “Compare votes and update dates across my monitored article list.”

### Data quality notes

Counts are snapshots from the public page at extraction time.

Optional source fields can be `null` when Zhihu does not expose them.

Plain text intentionally collapses whitespace for downstream analysis.

Markdown preserves meaningful headings, links, lists, and images where possible.

HTML is sanitized and does not include executable page scripts.

### Limitations

Zhihu can change its public page structure or apply regional rate limits.

The Actor cannot access login-only, private, deleted, or removed articles.

It does not discover article URLs for you.

It does not execute JavaScript or solve human verification challenges.

Engagement values can change after a run completes.

### Is it legal to scrape Zhihu articles?

Public web data can still be subject to copyright, database rights, privacy law, contract terms, and local regulation.

Use the Actor only for data you are authorized to collect.

Do not republish copyrighted article bodies without an appropriate legal basis.

Minimize personal data, respect deletion requests, and follow Zhihu's applicable terms.

This information is general guidance, not legal advice.

### Troubleshooting

#### Why did my URL fail validation?

Only public `zhuanlan.zhihu.com/p/{numeric-id}` article URLs are supported.

Question, answer, profile, search, and column-list URLs fail closed.

#### Why did the run return HTTP 403 or 429?

Reduce concurrency and try an Apify Proxy configuration appropriate for your lawful use case.

Avoid repeatedly retrying a restricted article.

#### Why did the run fail with no output?

The article may be private, deleted, incomplete, or blocked.

Review the log message for each submitted URL and test a known public article.

#### Why is an optional field null?

Zhihu does not expose every author, permission, or location field on every article.

The Actor preserves absence rather than inventing a value.

### FAQ

#### Can I scrape a list of Zhihu search results?

No. This version accepts known public article URLs only.

#### Can I scrape questions and answers?

No. Q\&A uses a different protected surface and is intentionally outside this Actor's scope.

#### Does it require cookies or a Zhihu account?

No for supported public article pages.

#### Can I obtain Markdown for RAG ingestion?

Yes. Use `contentMarkdown`, or use `contentText` for embedding pipelines that do not need structure.

#### Are duplicate URLs charged twice?

No. Canonical duplicates are removed within the run before fetching.

#### Can I schedule the Actor?

Yes. Save the input as an Apify Task and attach a schedule.

### Related scrapers

Explore other purpose-built tools from [Automation Labs](https://apify.com/automation-lab):

- [Reddit Scraper](https://apify.com/automation-lab/reddit-scraper) for communities, posts, and discussion research.
- [Medium Scraper](https://apify.com/automation-lab/medium-scraper) for English-language publishing workflows, when available.
- [G2 Scraper](https://apify.com/automation-lab/g2-scraper) for software review intelligence.

Use a related Actor only when its source and entity type match your workflow.

### Start extracting Zhihu articles

Paste a public Zhuanlan article URL, run the prefilled example, and inspect the structured dataset.

For recurring work, save the configuration as a task and connect the resulting dataset to your research or AI pipeline.

# Actor input Schema

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

Public article URLs in the form https://zhuanlan.zhihu.com/p/{numeric-id}. Q\&A, profile, search, and column-list URLs are not supported.

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

Maximum number of unique article records to save.

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

Parallel requests. Keep this low to reduce rate-limit risk on Zhihu.

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

Optional Apify Proxy or custom proxies. Useful when Zhihu returns HTTP 403 or 429 from your region.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://zhuanlan.zhihu.com/p/2055333119083992479"
    }
  ],
  "maxItems": 3,
  "maxConcurrency": 2,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

Open the default dataset overview containing one complete record per successfully extracted public article.

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "startUrls": [
        {
            "url": "https://zhuanlan.zhihu.com/p/2055333119083992479"
        }
    ],
    "maxItems": 3,
    "maxConcurrency": 2,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/zhihu-article-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "startUrls": [{ "url": "https://zhuanlan.zhihu.com/p/2055333119083992479" }],
    "maxItems": 3,
    "maxConcurrency": 2,
    "proxyConfiguration": { "useApifyProxy": False },
}

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

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

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

```

## CLI example

```bash
echo '{
  "startUrls": [
    {
      "url": "https://zhuanlan.zhihu.com/p/2055333119083992479"
    }
  ],
  "maxItems": 3,
  "maxConcurrency": 2,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call automation-lab/zhihu-article-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Zhihu Article Scraper",
        "description": "📝 Extract public Zhihu Zhuanlan articles by URL into clean text, Markdown and HTML, with authors, topics, images, timestamps, permissions and engagement metrics.",
        "version": "0.1",
        "x-build-id": "fNGu4AJW8pCG8uSgE"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~zhihu-article-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-zhihu-article-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~zhihu-article-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-zhihu-article-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~zhihu-article-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-zhihu-article-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "📝 Zhihu article URLs",
                        "type": "array",
                        "description": "Public article URLs in the form https://zhuanlan.zhihu.com/p/{numeric-id}. Q&A, profile, search, and column-list URLs are not supported.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum articles",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of unique article records to save.",
                        "default": 10
                    },
                    "maxConcurrency": {
                        "title": "Maximum concurrency",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Parallel requests. Keep this low to reduce rate-limit risk on Zhihu.",
                        "default": 3
                    },
                    "proxyConfiguration": {
                        "title": "🌐 Proxy configuration",
                        "type": "object",
                        "description": "Optional Apify Proxy or custom proxies. Useful when Zhihu returns HTTP 403 or 429 from your region."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```