# Sogou WeChat Article Search Scraper (`automation-lab/sogou-wechat-article-search-scraper`) Actor

🔎 Search public WeChat Official Account articles on Sogou and extract titles, snippets, accounts, dates, images, and result links.

- **URL**: https://apify.com/automation-lab/sogou-wechat-article-search-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Social media
- **Stats:** 4 total users, 3 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 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

## Sogou WeChat Article Search Scraper

Search public WeChat Official Account articles through Sogou WeChat search and export structured discovery metadata.

### What does Sogou WeChat Article Search Scraper do?

This actor queries `weixin.sogou.com` for public WeChat Official Account article search results.
It saves one dataset row per search result with title, snippet, account name, date, image, Sogou redirect URL, and source query.
It is designed for article discovery and monitoring, not for guaranteed full WeChat article-body extraction.

### Who is it for?

- 🧭 China market researchers tracking public WeChat discussion around brands or topics.
- 📣 PR teams monitoring campaigns, launches, and media coverage.
- 🛍️ E-commerce teams researching category and competitor mentions.
- 🧪 Analysts building repeatable social-listening datasets.

### Why use this actor?

Sogou is one of the few public web entry points for WeChat Official Account article discovery.
Instead of manually copying search results, you can run repeatable keyword searches and export data to JSON, CSV, Excel, Google Sheets, or your own API workflow.

### What data can you extract?

| Field | Description |
| --- | --- |
| `keyword` | Keyword or query extracted from a supplied Sogou URL |
| `title` | Clean article title |
| `snippet` | Search-result summary |
| `accountName` | WeChat Official Account name |
| `publishDateText` | Parsed publication date text |
| `publishTimestamp` | Timestamp from Sogou when available |
| `sogouUrl` | Sogou result redirect URL |
| `articleUrl` | Best-effort resolved article URL when enabled |
| `coverImageUrl` | Search-result thumbnail |
| `sourceUrl` | Exact search page fetched |
| `scrapedAt` | Extraction timestamp |

### How much does it cost to scrape Sogou WeChat article search results?

The actor uses pay-per-event pricing: a small one-time run start fee plus a per-result charge for each saved search result.
The current configured start fee is **$0.005 per run**. The per-result price depends on your Apify plan tier:

| Apify tier | Price per saved result |
| --- | ---: |
| FREE | $0.000063324 |
| BRONZE | $0.000055065 |
| SILVER | $0.000042950 |
| GOLD | $0.000033039 |
| PLATINUM | $0.000022026 |
| DIAMOND | $0.000015418 |

Example cost at the BRONZE tier: a 100-result monitoring run is about **$0.0105** before platform-level fees (`$0.005` start + `100 × $0.000055065`). A 1,000-result research export is about **$0.0601** before platform-level fees.
You can keep runs cheap by setting `maxItems` and `maxPagesPerQuery` to the volume you actually need.
The default input is intentionally small enough for a quick first test.

### How to use it

1. Open the Apify Store page for `automation-lab/sogou-wechat-article-search-scraper`.
2. Click **Try for free** or **Run** and open the input editor.
3. Add one or more keywords, such as brand names, campaign phrases, or Chinese category terms.
4. Set `maxItems` and `maxPagesPerQuery` to your desired search-result volume.
5. Keep URL resolution disabled unless you specifically need best-effort `mp.weixin.qq.com` links.
6. Run the actor and wait for the dataset to appear.
7. Export the dataset as CSV, JSON, Excel, Google Sheets, or through the Apify API.

### Input options

- `keywords` — search terms such as brand names, competitors, campaigns, or product categories.
- `searchUrls` — optional full Sogou WeChat search URLs.
- `maxItems` — total records to save.
- `maxPagesPerQuery` — number of Sogou result pages to request per query.
- `requestDelayMs` — delay between requests.
- `resolveArticleUrls` — best-effort redirect resolution, disabled by default.

### Output example

```json
{
  "keyword": "新能源汽车",
  "page": 1,
  "position": 1,
  "title": "73.7%!深圳新能源车渗透率碾压全国,凭什么是它?",
  "snippet": "新能源汽车渗透率,全国第一...",
  "accountName": "道哥说车",
  "publishDateText": "2026-07-08",
  "sogouUrl": "https://weixin.sogou.com/link?...",
  "articleUrl": null,
  "coverImageUrl": "https://img01.sogoucdn.com/v2/thumb?...",
  "sourceUrl": "https://weixin.sogou.com/weixin?type=2&query=...",
  "scrapedAt": "2026-07-08T05:35:00.566Z"
}
````

### Tips for reliable runs

- Use Chinese-language keywords when monitoring China-market content.
- Start with one to three keywords and increase volume after checking quality.
- Keep `requestDelayMs` above zero for larger runs.
- Leave `resolveArticleUrls` disabled if you only need discovery metadata.
- If Sogou throttles a query, retry later with lower page limits.

### Best-effort article URL resolution

Sogou result links often redirect through anti-spider checks.
For that reason, the actor always saves the Sogou URL and only attempts direct article URL resolution when you enable `resolveArticleUrls`.
If Sogou returns an antispider page, the actor keeps `articleUrl` as `null` instead of failing the whole run.

### Integrations

Use the dataset with:

- Google Sheets for editorial review queues.
- Apify webhooks for daily monitoring jobs.
- BI tools for trend dashboards.
- LLM workflows for clustering titles and snippets.
- CRM or PR tools for campaign evidence logs.

### 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/sogou-wechat-article-search-scraper').call({
  keywords: ['新能源汽车'],
  maxItems: 100
});
console.log(run.defaultDatasetId);
```

#### Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/sogou-wechat-article-search-scraper').call(run_input={
    'keywords': ['品牌营销'],
    'maxItems': 100,
})
print(run['defaultDatasetId'])
```

#### cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~sogou-wechat-article-search-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"keywords":["跨境电商"],"maxItems":100}'
```

### Use with AI agents via MCP

Sogou WeChat Article Search Scraper is available as a tool for AI assistants that support the Model Context Protocol (MCP).

Add the Apify MCP server to Claude Code:

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

For Claude Desktop, Cursor, or VS Code, add this actor-scoped JSON config:

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

Example prompts:

- "Use automation-lab/sogou-wechat-article-search-scraper to search WeChat Official Account articles about 新能源汽车 and summarize the top recurring themes."
- "Find recent WeChat article search results for my competitor brand and create a monitoring table."
- "Run a Sogou WeChat search for three campaign keywords and group the article snippets by account."

### Example workflows

#### Brand monitoring

Run the actor daily for your brand name and competitor names.
Export titles, snippets, and account names to a dashboard.
Flag new articles that mention product launches or controversies.

#### Content research

Search broad topics such as AI, cross-border e-commerce, or electric vehicles.
Review high-ranking WeChat Official Account articles and identify themes for your own editorial calendar.

#### PR evidence collection

Search campaign slogans and product names after an announcement.
Save result URLs and snippets as evidence of public WeChat coverage.

### FAQ

**Can this actor scrape full WeChat article bodies?**

No. It is designed for Sogou WeChat search-result metadata. Direct article URL resolution is best-effort because Sogou redirects can trigger antispider checks.

**How fast is it?**

A 100-result run usually finishes in under one minute with a conservative delay between Sogou result pages.

**How much does it cost?**

Costs scale mostly with saved article results. At BRONZE pricing, a 100-result run is about $0.0105 before platform-level fees, and a 1,000-result run is about $0.0601 before platform-level fees. Keep `maxItems` low for tests and increase it for scheduled monitoring jobs.

**Is this the same as the WeChat API?**

No. It uses publicly reachable Sogou search-result pages and does not require a WeChat API key or login.

### Troubleshooting

#### Why is `articleUrl` null?

Sogou redirect resolution can trigger antispider checks.
The actor preserves the Sogou URL so you still have a usable discovery link.
Enable `resolveArticleUrls` only when you need best-effort direct links.

#### Why did a run return fewer results than requested?

Sogou may have fewer public results for a query, repeat results across pages, or throttle specific terms.
Try more keywords, lower page speed, or a more common Chinese phrase.

### Legality and responsible use

This actor extracts publicly reachable search-result metadata.
You are responsible for ensuring your use case complies with applicable laws, Sogou/WeChat terms, and privacy rules.
Do not use the actor to collect private account data or bypass access controls.

### Related scrapers

- https://apify.com/automation-lab/1688-scraper
- https://apify.com/automation-lab/chinese-brand-monitor
- https://apify.com/automation-lab/website-contact-finder

### Limits

The actor does not log in to WeChat.
It does not guarantee full article bodies.
It does not bypass Sogou antispider challenges.
It focuses on stable search-result metadata.

### Changelog

- 0.1 — Initial HTTP + Cheerio implementation for Sogou WeChat article search metadata.

### Support

If you need a missing output field or a different Sogou filter, open an Apify issue with your input and expected output.

### Quick checklist

- Add keywords.
- Set result limit.
- Run.
- Export dataset.
- Use Sogou URLs for manual review or downstream analysis.

# Actor input Schema

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

Search keywords to query on Sogou WeChat article search, for example brand names, topics, competitors, or campaign phrases.

## `searchUrls` (type: `array`):

Optional full Sogou WeChat search URLs. Use this when you already have a filtered search URL from weixin.sogou.com.

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

Maximum article result records to save across all keywords and URLs.

## `maxPagesPerQuery` (type: `integer`):

Maximum Sogou result pages to request for each keyword or search URL.

## `requestDelayMs` (type: `integer`):

Polite delay between search-result page requests. Increase this if Sogou starts throttling your run.

## `resolveArticleUrls` (type: `boolean`):

Try to resolve Sogou redirect links to mp.weixin.qq.com article URLs. This can trigger Sogou anti-spider pages, so it is disabled by default.

## Actor input object example

```json
{
  "keywords": [
    "AI",
    "新能源汽车"
  ],
  "searchUrls": [],
  "maxItems": 20,
  "maxPagesPerQuery": 10,
  "requestDelayMs": 800,
  "resolveArticleUrls": false
}
```

# 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": [
        "AI",
        "新能源汽车"
    ],
    "searchUrls": [],
    "maxItems": 20,
    "maxPagesPerQuery": 10,
    "requestDelayMs": 800,
    "resolveArticleUrls": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/sogou-wechat-article-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 = {
    "keywords": [
        "AI",
        "新能源汽车",
    ],
    "searchUrls": [],
    "maxItems": 20,
    "maxPagesPerQuery": 10,
    "requestDelayMs": 800,
    "resolveArticleUrls": False,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/sogou-wechat-article-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 '{
  "keywords": [
    "AI",
    "新能源汽车"
  ],
  "searchUrls": [],
  "maxItems": 20,
  "maxPagesPerQuery": 10,
  "requestDelayMs": 800,
  "resolveArticleUrls": false
}' |
apify call automation-lab/sogou-wechat-article-search-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Sogou WeChat Article Search Scraper",
        "description": "🔎 Search public WeChat Official Account articles on Sogou and extract titles, snippets, accounts, dates, images, and result links.",
        "version": "0.1",
        "x-build-id": "ZBW2H9dOwjKefe8Jg"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~sogou-wechat-article-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-sogou-wechat-article-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/automation-lab~sogou-wechat-article-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-sogou-wechat-article-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/automation-lab~sogou-wechat-article-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-sogou-wechat-article-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",
                "properties": {
                    "keywords": {
                        "title": "Keywords",
                        "type": "array",
                        "description": "Search keywords to query on Sogou WeChat article search, for example brand names, topics, competitors, or campaign phrases.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchUrls": {
                        "title": "Sogou WeChat search URLs",
                        "type": "array",
                        "description": "Optional full Sogou WeChat search URLs. Use this when you already have a filtered search URL from weixin.sogou.com.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum articles",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum article result records to save across all keywords and URLs.",
                        "default": 20
                    },
                    "maxPagesPerQuery": {
                        "title": "Maximum pages per query",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Maximum Sogou result pages to request for each keyword or search URL.",
                        "default": 10
                    },
                    "requestDelayMs": {
                        "title": "Delay between requests (ms)",
                        "minimum": 0,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Polite delay between search-result page requests. Increase this if Sogou starts throttling your run.",
                        "default": 800
                    },
                    "resolveArticleUrls": {
                        "title": "Best-effort resolve article URLs",
                        "type": "boolean",
                        "description": "Try to resolve Sogou redirect links to mp.weixin.qq.com article URLs. This can trigger Sogou anti-spider pages, so it is disabled by default.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```