# 🔍 Baidu Search Scraper (`scrapier/baidu-search-scraper`) Actor

Scrape Baidu search results at scale. Extract organic listings, answer boxes, related videos, related searches, and top searches. Supports bulk queries, proxy fallback, date filters, and device/language options for SEO and market research.

- **URL**: https://apify.com/scrapier/baidu-search-scraper.md
- **Developed by:** [Scrapier](https://apify.com/scrapier) (community)
- **Categories:** SEO tools, Developer tools, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.99 / 1,000 results

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

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

### 🔍 Baidu Search Scraper

The 🔍 Baidu Search Scraper is a fast, scalable Baidu SERP scraper that extracts organic listings, answer boxes, related videos, people also search for, related searches, and top searches from public Baidu results pages. It solves the challenge of collecting clean, structured SERP data at scale with a smart proxy fallback strategy and bulk query support. Built for marketers, developers, data analysts, and researchers, this Baidu search results scraper tool helps you run SEO analysis, market research, and competitor tracking with consistent, repeatable output—unlocking automation-ready Baidu SERP data at scale.

### What data / output can you get?

Below are the structured fields pushed to the Apify dataset in real time for each SERP element:

| Data field | Description | Example value |
| --- | --- | --- |
| query | The search query associated with the result row | "python tutorial" |
| resultType | Result category: organic, answer_box, related_video, people_also_search_for, related_search, top_search | "organic" |
| title | Title of the organic result or video | "Python Tutorial - W3Schools" |
| link | Canonical URL to the result (decoded from Baidu redirect when applicable) | "https://www.w3schools.com/python/" |
| snippet | Text snippet/description for organic results | "Learn Python with examples, exercises, and projects..." |
| displayedLink | Displayed domain or path extracted from the link | "www.w3schools.com" |
| thumbnail | Image URL (if present for organic or video blocks) | "https://img.example.com/thumb.jpg" |
| position | Calculated position among organic results across pages | 1 |
| content | Answer/content text for answer boxes | "Python is a high-level programming language..." |
| source | Source attribution for answer boxes | "Baidu Baike" |
| searchTerm | Related search term (for people_also_search_for, related_search, top_search) | "learn python online" |
| richSnippet | Additional rich text extracted from organic blocks (if present) | "Beginner-friendly · Free certificate" |

Notes:
- Results are stored as individual rows for real-time visibility during the run.
- You can export data to JSON or CSV from the dataset.
- Optionally, if you set outputFile, a summary JSON with totals and grouped results is saved to the key-value store.

### Key features

- 🧠 Intelligent proxy fallback  
  Starts with no proxy to save cost. If Baidu blocks, automatically falls back to datacenter and then residential proxies (3 retries). Once residential works, it sticks with it for the remaining requests.

- 📦 Bulk keyword scraping  
  Supply multiple Baidu URLs or plain search terms and process them in a single run for high-throughput workflows.

- 📱 Device & language targeting  
  Control deviceType (desktop, mobile, tablet) and languageLocalization (All, Simplified Chinese, Traditional Chinese) to compare different SERP layouts and regions.

- 📅 Time period filtering  
  Use timePeriod to filter by startDate/endDate or daysAgo and narrow results to recent content.

- 📊 Structured SERP coverage  
  Extracts organic results, answer boxes, related videos, people also search for, related searches, and top searches with clean fields.

- ⚡ Real-time dataset output  
  Pushes each result row to the Apify dataset during the run, so you can monitor progress live and export JSON/CSV at completion.

- 💾 Optional summary export  
  Set outputFile to also save a consolidated JSON (with totals and results_by_query) to the key-value store for easy retrieval.

- 🛡️ Production-ready robustness  
  Retries, fallbacks, and clear logging help keep your runs successful and predictable—even for large batches.

### How to use Baidu Search Scraper - step by step

1. Create or log in to your Apify account at https://console.apify.com.
2. Go to Actors and open “baidu-search-scraper”.
3. Add your input:
   - Paste Baidu search URLs or plain terms into urls (one per line).
   - Choose deviceType (desktop/mobile/tablet) and languageLocalization.
   - Set numResults and maxPagination to control depth.
   - Optionally configure timePeriod and proxyConfiguration.
4. Click Start to run the actor.
5. Watch progress in real time—rows appear in the dataset as they’re extracted.
6. Open the OUTPUT tab to view the dataset and export to JSON or CSV.
7. (Optional) Set outputFile to save a consolidated summary JSON to the key-value store.

Pro Tip: To compare mobile vs. desktop rankings programmatically, run two jobs with different deviceType values and diff results by position.

### Use cases

| Use case | Description |
| --- | --- |
| SEO research & competitor analysis | Track competitor rankings and SERP features using a reliable Baidu ranking scraper with device and language targeting. |
| Market research & trend monitoring | Monitor “top searches” and “people also search for” to identify rising topics and audience interests. |
| Content discovery & topic planning | Gather related searches to inform content briefs, clusters, and internal linking strategies. |
| Academic/behavioral research | Analyze SERP structures and related queries for research into search behavior in Chinese markets. |
| Bulk keyword auditing | Run large keyword sets in one batch to audit performance and identify low-competition opportunities. |
| SERP feature mapping | Capture answer boxes and related videos to understand how Baidu SERP features influence visibility. |

### Why choose Baidu Search Scraper?

Build for precision and scale, this Baidu search engine scraper delivers structured SERP data with smart proxy management and clean output.

- 🎯 Accurate, structured output with clearly defined fields per result type
- 🌍 Language and device controls for regional and layout comparisons
- 📈 Scales to large keyword lists with consistent performance
- 👨‍💻 Developer-friendly JSON/CSV exports via the Apify dataset
- 🛡️ Safe and ethical: collects only publicly available data
- 💸 Cost-aware: no proxy by default, with automatic fallback only when needed
- 🧱 More reliable than browser extensions or ad-hoc tools, with robust retries and logging

Bottom line: a dependable Baidu SERP data extractor that’s production-ready for recurring workflows.

### Is it legal / ethical to use Baidu Search Scraper?

Yes—when used responsibly. This actor collects data from publicly available Baidu search results and does not access private or password-protected content. As with any web data collection:
- Only scrape publicly available information.
- Ensure compliance with applicable regulations (e.g., GDPR, CCPA).
- Review Baidu’s terms and your organization’s policies.
- Do not use the tool for spam or misuse of data.

Users are responsible for ensuring legal compliance for their specific use case.

### Input parameters & output format

Example JSON input
```json
{
  "urls": [
    "python tutorial",
    "machine learning"
  ],
  "deviceType": "desktop",
  "languageLocalization": 1,
  "startPage": 1,
  "numResults": 10,
  "timePeriod": {
    "daysAgo": 7
  },
  "maxPagination": 3,
  "outputFile": "baidu_serp_summary",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
````

Input parameters

- urls (array, required)\
  Description: Baidu search URLs (e.g., https://www.baidu.com/s?wd=python) OR plain search terms. Add one per line for bulk scraping. Default: none
- deviceType (string)\
  Description: Desktop = www.baidu.com (default). Mobile/Tablet = m.baidu.com. Use to scrape mobile vs desktop SERP. Default: "desktop"
- languageLocalization (integer)\
  Description: 1 = All languages (default). 2 = Simplified Chinese (简体中文). 3 = Traditional Chinese (繁體中文). Default: 1
- startPage (integer)\
  Description: Page number to start scraping from. 1 = first page. Default: 1
- numResults (integer)\
  Description: Number of results per page (1–50). Baidu typically shows 10. Default: 10
- timePeriod (object)\
  Description: Optional date range filter. Use startDate + endDate (YYYY-MM-DD) for custom range, or daysAgo for “last N days”. Default: empty object with defaults
  - startDate (string) – From date (YYYY-MM-DD). Default: ""
  - endDate (string) – To date (YYYY-MM-DD). Default: ""
  - daysAgo (integer) – Alternative: filter to last N days. Set 0 to disable. Default: 0
- maxPagination (integer)\
  Description: Max pages to scrape per query. 0 = no limit (capped at 10). Default: 3
- outputFile (string)\
  Description: Optional custom key for key-value store. Results are always saved to the Apify dataset; if set, also saves a consolidated JSON to KVS with this name. Default: ""
- proxyConfiguration (object)\
  Description: By default: no proxy. If Baidu blocks → datacenter → residential (3 retries). Enable Apify proxy here if you want to start with proxy (fallback still applies). Default: { "useApifyProxy": false }

Example dataset row output (pushed during the run)

```json
{
  "query": "python tutorial",
  "resultType": "organic",
  "title": "Python Tutorial - W3Schools",
  "link": "https://www.w3schools.com/python/",
  "snippet": "Learn Python with examples, exercises, and projects...",
  "displayedLink": "www.w3schools.com",
  "thumbnail": "https://img.example.com/thumb.jpg",
  "position": 1,
  "richSnippet": "Beginner-friendly · Free certificate"
}
```

Other result types use the same row structure with type-specific fields:

- answer\_box rows include: title, content, source.
- related\_video rows include: title, link, thumbnail.
- people\_also\_search\_for, related\_search, top\_search rows include: searchTerm and (when available) link.

Optional summary JSON (saved to key-value store when outputFile is set)

```json
{
  "summary": {
    "total_queries": 2,
    "queries": ["python tutorial", "machine learning"],
    "total_organic_results": 20,
    "total_answer_boxes": 2,
    "total_related_videos": 1,
    "total_people_also_search_for": 8,
    "total_related_searches": 10,
    "total_top_searches": 6
  },
  "results_by_query": {
    "python tutorial": {
      "query": "python tutorial",
      "organic_results": [],
      "answer_box": [],
      "related_videos": [],
      "people_also_search_for": [],
      "related_searches": [],
      "top_searches": []
    }
  }
}
```

### FAQ

#### Does it work without a proxy?

Yes. By default it uses no proxy. If Baidu blocks requests, it automatically falls back to Apify datacenter proxy and then residential proxy with up to 3 retries.

#### Can I use my own proxy or start with a proxy?

Yes. Configure proxyConfiguration in the input to enable Apify Proxy from the start. The automatic fallback still applies if a block occurs.

#### Can I target mobile vs. desktop SERPs?

Yes. Set deviceType to desktop, mobile, or tablet. Mobile/Tablet uses m.baidu.com, which can produce different SERP layouts and results.

#### How do I filter results by date?

Use timePeriod. Provide startDate and endDate for a custom range, or set daysAgo (e.g., 7 for “last week”). Leave it empty to disable filtering.

#### How many results can I extract per query?

Control depth with numResults (1–50 per page) and maxPagination (0–10 pages; 0 caps at 10). The actor aggregates organic positions across pages.

#### What data types are included beyond organic results?

In addition to organic results, the scraper extracts answer boxes, related videos, people also search for, related searches, and top searches when present.

#### Where do results go and how can I export them?

Rows are pushed to the Apify dataset during the run. You can view them in the OUTPUT tab and export to JSON or CSV. If you set outputFile, a consolidated summary JSON is also saved to the key-value store.

#### Is this a Baidu SERP API I can use with Python?

You can run the actor on Apify and access results programmatically via the dataset (download JSON/CSV) to integrate with Python or other workflows, effectively using it as a Baidu search results API for your pipelines.

### Final thoughts

The 🔍 Baidu Search Scraper is built for structured, scalable Baidu SERP data extraction. With intelligent proxy fallback, bulk query support, and precise output fields, it’s ideal for marketers, developers, analysts, and researchers. Export clean JSON/CSV from the dataset or save a consolidated summary to the key-value store for downstream automation. Start extracting smarter Baidu SEO insights and build repeatable workflows for analysis, enrichment, and reporting.

# Actor input Schema

## `urls` (type: `array`):

📝 **What to enter:** Baidu search URLs (e.g. https://www.baidu.com/s?wd=python) OR plain search terms (e.g. python tutorial, machine learning). Add one per line for bulk scraping.

💡 **Tip:** Use plain terms for simplicity. URLs are parsed automatically to extract the query.

## `deviceType` (type: `string`):

🖥️ **Desktop** = www.baidu.com (default). 📱 **Mobile/Tablet** = m.baidu.com. Use to scrape mobile vs desktop SERP (different layouts & results).

## `languageLocalization` (type: `integer`):

1 = All languages (default). 2 = Simplified Chinese (简体中文). 3 = Traditional Chinese (繁體中文). Affects search result language/region.

## `startPage` (type: `integer`):

Page number to start scraping from. 1 = first page (default). Use 2+ to skip earlier pages (e.g. for pagination continuation).

## `numResults` (type: `integer`):

Number of results per page (1–50). Baidu typically shows 10. Higher = more results per request. Use with maxPagination for total result cap.

## `timePeriod` (type: `object`):

Optional date range filter. Leave empty for no filter (all results). Use Start Date + End Date for custom range, OR Days Ago for "last N days" (e.g. 7 = last week).

## `maxPagination` (type: `integer`):

Max pages to scrape per query. 0 = no limit (capped at 10). 3 = first 3 pages. More pages = more results but longer run time.

## `outputFile` (type: `string`):

Optional custom key for key-value store. Results are always saved to Apify dataset. If set, also saves to KVS with this name for easy retrieval.

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

By default: no proxy. If Baidu blocks → datacenter → residential (3 retries). Enable Apify proxy here if you want to start with proxy. Fallback still applies when blocked.

## Actor input object example

```json
{
  "urls": [
    "python tutorial"
  ],
  "deviceType": "desktop",
  "languageLocalization": 1,
  "startPage": 1,
  "numResults": 10,
  "maxPagination": 3,
  "outputFile": "",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# 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 = {
    "urls": [
        "python tutorial"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapier/baidu-search-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 = {
    "urls": ["python tutorial"],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapier/baidu-search-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 '{
  "urls": [
    "python tutorial"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call scrapier/baidu-search-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "🔍 Baidu Search Scraper",
        "description": "Scrape Baidu search results at scale. Extract organic listings, answer boxes, related videos, related searches, and top searches. Supports bulk queries, proxy fallback, date filters, and device/language options for SEO and market research.",
        "version": "0.1",
        "x-build-id": "A0o82NhSfBkVnTcOa"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapier~baidu-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapier-baidu-search-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/scrapier~baidu-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapier-baidu-search-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/scrapier~baidu-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapier-baidu-search-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": [
                    "urls"
                ],
                "properties": {
                    "urls": {
                        "title": "🔎 Search Queries (required)",
                        "type": "array",
                        "description": "📝 **What to enter:** Baidu search URLs (e.g. https://www.baidu.com/s?wd=python) OR plain search terms (e.g. python tutorial, machine learning). Add one per line for bulk scraping.\n\n💡 **Tip:** Use plain terms for simplicity. URLs are parsed automatically to extract the query.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "deviceType": {
                        "title": "📱 Device Type",
                        "enum": [
                            "desktop",
                            "mobile",
                            "tablet"
                        ],
                        "type": "string",
                        "description": "🖥️ **Desktop** = www.baidu.com (default). 📱 **Mobile/Tablet** = m.baidu.com. Use to scrape mobile vs desktop SERP (different layouts & results).",
                        "default": "desktop"
                    },
                    "languageLocalization": {
                        "title": "🌐 Language",
                        "minimum": 1,
                        "maximum": 3,
                        "type": "integer",
                        "description": "1 = All languages (default). 2 = Simplified Chinese (简体中文). 3 = Traditional Chinese (繁體中文). Affects search result language/region.",
                        "default": 1
                    },
                    "startPage": {
                        "title": "📄 Starting Page",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Page number to start scraping from. 1 = first page (default). Use 2+ to skip earlier pages (e.g. for pagination continuation).",
                        "default": 1
                    },
                    "numResults": {
                        "title": "📊 Results Per Page",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Number of results per page (1–50). Baidu typically shows 10. Higher = more results per request. Use with maxPagination for total result cap.",
                        "default": 10
                    },
                    "timePeriod": {
                        "title": "📅 Time Period Filter",
                        "type": "object",
                        "description": "Optional date range filter. Leave empty for no filter (all results). Use Start Date + End Date for custom range, OR Days Ago for \"last N days\" (e.g. 7 = last week).",
                        "properties": {
                            "startDate": {
                                "title": "📆 Start Date",
                                "type": "string",
                                "editor": "datepicker",
                                "description": "From date (YYYY-MM-DD). Used with End Date for custom range. Ignored if Days Ago is set.",
                                "default": ""
                            },
                            "endDate": {
                                "title": "📆 End Date",
                                "type": "string",
                                "editor": "datepicker",
                                "description": "To date (YYYY-MM-DD). Used with Start Date for custom range. Ignored if Days Ago is set.",
                                "default": ""
                            },
                            "daysAgo": {
                                "title": "⏱️ Days Ago",
                                "type": "integer",
                                "description": "Alternative: filter to last N days. e.g. 7 = last week, 30 = last month. Set to 0 to disable (use Start/End dates or no filter).",
                                "minimum": 0,
                                "default": 0
                            }
                        }
                    },
                    "maxPagination": {
                        "title": "📑 Maximum Pages",
                        "minimum": 0,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Max pages to scrape per query. 0 = no limit (capped at 10). 3 = first 3 pages. More pages = more results but longer run time.",
                        "default": 3
                    },
                    "outputFile": {
                        "title": "💾 Output File",
                        "type": "string",
                        "description": "Optional custom key for key-value store. Results are always saved to Apify dataset. If set, also saves to KVS with this name for easy retrieval.",
                        "default": ""
                    },
                    "proxyConfiguration": {
                        "title": "🔒 Proxy Configuration",
                        "type": "object",
                        "description": "By default: no proxy. If Baidu blocks → datacenter → residential (3 retries). Enable Apify proxy here if you want to start with proxy. Fallback still applies when blocked."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
