# MCP Web Scraper Server — AI-Ready Web Scraping via MCP (`junipr/mcp-web-scraper`) Actor Model Context Protocol (MCP) server for web scraping. Provides scrape, extract, search, and link discovery tools via SSE or WebSocket transport. Connect AI agents and LLMs to live web data. - **URL**: https://apify.com/junipr/mcp-web-scraper.md - **Developed by:** [junipr](https://apify.com/junipr) (community) - **Categories:** AI, Developer tools - **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks - **User rating**: No ratings yet ## Pricing $3.90 / 1,000 mcp tool calls This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events. 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 ## MCP Web Scraper Server > **Pricing:** $3.90 per 1,000 tool calls (Pay-Per-Event) — no subscription required > **Protocol:** Model Context Protocol (MCP) — JSON-RPC 2.0 over SSE or stdio ### Introduction The Model Context Protocol (MCP) is an open standard for connecting AI assistants to external tools and data sources. Instead of hard-coding a scraping library into your agent, you connect the agent to an MCP server and it gains instant access to web data through a clean, standardized interface. This actor is an MCP server that runs on Apify's infrastructure and exposes four powerful tools for web data retrieval: `scrape_url`, `extract_content`, `search_web`, and `get_links`. Any MCP-compatible AI client can connect and start making tool calls immediately — no API keys, no server setup, no infrastructure to maintain. **Compatible with:** Claude Desktop, Claude Code, Cursor, Windsurf, VS Code Copilot, LangChain, CrewAI, AutoGPT, the OpenAI Agents SDK, and any client that implements the MCP specification. Unlike a regular scraper actor that runs once and exits, this actor stays alive in Apify's Standby mode, keeping a persistent connection open for your AI agent to use throughout a conversation or autonomous workflow. The agent calls tools, gets results, and continues — exactly like calling a local function, but backed by Apify's residential proxy network and full Playwright browser fleet. ### Available Tools #### `scrape_url` — Full page scraping Fetches a URL and returns the content in your preferred format. Supports JavaScript rendering for single-page apps, configurable CSS selector removal, content chunking for RAG pipelines, and full page metadata extraction. ```json { "name": "scrape_url", "arguments": { "url": "https://example.com/article", "outputFormat": "markdown", "enableChunking": true, "chunkSize": 1000 } } ```` #### `extract_content` — Targeted extraction Extract specific elements from a page using CSS selectors or a natural language description. Useful when you need only the product price, the article body, or a table — not the entire page. ```json { "name": "extract_content", "arguments": { "url": "https://shop.example.com/product", "description": "product name and price", "outputFormat": "json" } } ``` #### `search_web` — Web search with optional page scraping Search Google, Bing, or DuckDuckGo and get structured results including titles, URLs, and snippets. Optionally scrape each result page and include its content. ```json { "name": "search_web", "arguments": { "query": "best JavaScript frameworks 2025", "maxResults": 10, "searchEngine": "google" } } ``` #### `get_links` — Link extraction and analysis Extract all links from a page and categorize them as internal, external, image, document, or social. Optionally check the HTTP status of each link for broken link detection. ```json { "name": "get_links", "arguments": { "url": "https://example.com", "type": "external", "checkStatus": false } } ``` ### How to Connect #### Claude Desktop Add to `~/Library/Application Support/Claude/claude_desktop_config.json` (macOS) or `%APPDATA%\Claude\claude_desktop_config.json` (Windows): ```json { "mcpServers": { "junipr-web-scraper": { "transport": "sse", "url": "https://mcp-web-scraper.apify.actor/sse", "headers": { "Authorization": "Bearer YOUR_APIFY_TOKEN" } } } } ``` #### Claude Code ```bash claude mcp add junipr-web-scraper --transport sse "https://mcp-web-scraper.apify.actor/sse" ``` #### Cursor / Windsurf In your MCP settings file, add the SSE connection pointing to `https://mcp-web-scraper.apify.actor/sse` with your Apify token as a Bearer header. #### LangChain (Python) ```python from langchain_mcp_adapters.client import MultiServerMCPClient client = MultiServerMCPClient({ "web_scraper": { "transport": "sse", "url": "https://mcp-web-scraper.apify.actor/sse", "headers": {"Authorization": "Bearer YOUR_APIFY_TOKEN"}, } }) tools = await client.get_tools() ``` #### Custom Client (direct SSE) Connect with an HTTP GET to the SSE endpoint. The server will send an `endpoint` event with the URL to POST MCP messages to, following the standard MCP SSE transport specification. ``` GET https://mcp-web-scraper.apify.actor/sse Authorization: Bearer YOUR_APIFY_TOKEN ``` ### Configuration The following actor-level inputs control global server behavior. Configure them in the Apify Console before starting the actor. | Parameter | Default | Description | |-----------|---------|-------------| | `transport` | `"sse"` | `"sse"` for HTTP clients, `"stdio"` for local testing | | `defaultRenderJs` | `true` | Default JavaScript rendering (agents can override per call) | | `maxConcurrentRequests` | `5` | Max simultaneous scraping operations (1–20) | | `defaultProxyGroup` | `"RESIDENTIAL"` | `"RESIDENTIAL"`, `"DATACENTER"`, or `"NONE"` | | `maxPageSizeBytes` | `5242880` | Max page size before truncation (5 MB default) | | `defaultTimeout` | `30000` | Per-request timeout in milliseconds | | `enableSearchTool` | `true` | Whether `search_web` is available to agents | | `rateLimitPerMinute` | `60` | Max tool calls per minute (prevents runaway agents) | | `allowedDomains` | `[]` | If non-empty, restrict scraping to these domains only | | `blockedDomains` | `[...]` | Domains agents cannot scrape (SSRF prevention) | ### Output Formats Each tool returns a JSON response wrapped in the MCP protocol envelope: ```json { "jsonrpc": "2.0", "id": "req-1", "result": { "content": [{ "type": "text", "text": "{...tool response JSON...}" }], "isError": false } } ``` The `text` field contains the tool-specific response. For `scrape_url`, this includes `content.markdown`, `metadata.title`, `metadata.wordCount`, timing info, and optional `chunks` for RAG pipelines. For `search_web`, it includes an array of `results` with position, title, URL, and snippet. Monitor real-time session statistics via the `scraper://usage` MCP resource, which returns total calls, total errors, and session start time. ### Pricing and Usage This actor uses Pay-Per-Event (PPE) pricing at **$3.90 per 1,000 tool calls** ($0.0039 per call). Pricing includes all platform compute costs — no hidden fees. A billable event is counted when an MCP client sends a valid tool call (`scrape_url`, `extract_content`, `search_web`, or `get_links`) and the server processes it and returns a response. Protocol handshakes, tool listings, resource reads, and rate-limited rejections are not billed. | Scenario | Calls | Cost | |----------|-------|------| | Research session (20 searches + 30 scrapes) | 50 | $0.19 | | Website audit (100 pages + link check) | 101 | $0.39 | | Daily monitoring (10 URLs, 30 days) | 300 | $1.17 | | AI agent workflow (200 calls/day, 30 days) | 6,000 | $23.40 | Apify Standby mode compute time is billed separately from PPE events (approximately $0.001/min while idle). The actor automatically shuts down after 5 minutes of inactivity to minimize idle costs. ### Security and Limitations **SSRF prevention:** The server blocks requests to localhost, private IP ranges (10.x, 192.168.x, 172.16–31.x), link-local addresses (169.254.x), and any domain in the `blockedDomains` configuration. This prevents agents from inadvertently accessing internal network resources. **Domain allowlisting:** Set `allowedDomains` to restrict agents to a specific set of domains. Useful in enterprise deployments where agents should only access your own data sources. **Rate limiting:** The `rateLimitPerMinute` setting prevents a runaway agent from making thousands of calls per minute. Rate-limited requests receive a `RATE_LIMITED` error with a `retryAfter` field indicating when to retry. **What this actor cannot do:** - Bypass paywalls or authentication-protected pages - Solve CAPTCHAs (returns `CAPTCHA_DETECTED` error instead) - Maintain persistent browser sessions between separate actor runs - Guarantee results for sites with aggressive anti-bot measures ### Related Actors - [RAG Web Content Extractor](https://apify.com/junipr/rag-web-extractor) — Bulk web extraction optimized for RAG pipelines ### FAQ #### What is MCP and why should I use this? MCP (Model Context Protocol) is an open standard published by Anthropic that defines how AI assistants connect to external tools. Instead of writing custom code to give your AI agent access to a scraper, you point it at an MCP server and it can immediately call tools to fetch web data. This actor provides those tools running on Apify's infrastructure — no server to maintain, no proxies to configure, no browser to install. #### Which AI tools support MCP? Claude Desktop, Claude Code, Cursor, Windsurf, VS Code Copilot, LibreChat, and most major AI coding assistants support MCP natively. LangChain, CrewAI, AutoGPT, and the OpenAI Agents SDK support MCP via adapter libraries. The protocol is rapidly becoming the standard for AI tool connectivity in 2025–2026. #### How do I connect this to Claude Desktop? Add an entry to your `claude_desktop_config.json` file with the SSE transport pointing to `https://mcp-web-scraper.apify.actor/sse` and your Apify API token as a Bearer header. Restart Claude Desktop. The four tools will appear in the tool picker automatically. #### Can I use this with LangChain? Yes. Use the `langchain-mcp-adapters` package (Python) or `@langchain/mcp-adapters` (TypeScript). Point the SSE transport at the actor's endpoint with your Apify token. The tools will be auto-discovered and usable as standard LangChain tools. #### How is this different from a regular scraper actor? A regular scraper actor runs once, processes a list of URLs, saves output to a dataset, and exits. This actor is a persistent MCP server that stays alive and responds to on-demand tool calls from AI agents. The agent decides in real time which URLs to fetch based on its reasoning — it is not a batch job. #### What does a "tool call" cost? Each MCP tool call costs $0.0039 (about four-tenths of a cent). A `search_web` call with `scrapeResults: true` that internally scrapes 10 pages still counts as 1 tool call, not 11. Failed calls that return errors are still billed because the server did the work of attempting the request. #### Can I restrict which domains agents can scrape? Yes. Set `allowedDomains` to a list of domains (e.g., `["docs.mycompany.com", "api.myservice.com"]`). Any agent attempt to scrape a domain not on this list will receive a `DOMAIN_BLOCKED` error. You can also add domains to `blockedDomains` to supplement the default SSRF blocklist. #### Does this support authentication or cookies? The `scrape_url` tool does not currently support passing custom cookies or authentication headers per call. For authenticated scraping, consider the [RAG Web Content Extractor](https://apify.com/junipr/rag-web-extractor) actor which supports cookie injection. This limitation exists intentionally to prevent misuse of the MCP server's proxy network for credential-based access. # Actor input Schema ## `transport` (type: `string`): Transport protocol for MCP communication. 'sse' uses Server-Sent Events for HTTP-based connections (recommended for Apify deployment). 'stdio' uses standard I/O for local testing. ## `defaultRenderJs` (type: `boolean`): Default setting for JavaScript rendering in scrape\_url calls. Agents can override this per call. Disable to reduce compute costs for static sites. ## `maxConcurrentRequests` (type: `integer`): Maximum number of simultaneous scraping operations. Higher values improve throughput but increase memory usage. ## `defaultProxyGroup` (type: `string`): Default Apify proxy group for scraping requests. RESIDENTIAL provides best success rate. DATACENTER is faster and cheaper. NONE disables proxy. ## `maxPageSizeBytes` (type: `integer`): Maximum page size in bytes. Pages larger than this are truncated. Default is 5MB. ## `defaultTimeout` (type: `integer`): Default timeout per request in milliseconds. Agents can override this per call. ## `enableSearchTool` (type: `boolean`): Enable the search\_web MCP tool. Disable to restrict agents to scraping and extraction only. ## `rateLimitPerMinute` (type: `integer`): Maximum MCP tool calls per minute across all connected clients. Prevents runaway agents from incurring unexpected costs. ## `allowedDomains` (type: `array`): If non-empty, agents can only scrape these domains. Useful for enterprise deployments to restrict scope. Leave empty to allow all non-blocked domains. ## `blockedDomains` (type: `array`): Domains that agents are not allowed to scrape. Prevents SSRF attacks. The defaults block all localhost and internal network addresses. ## Actor input object example ```json { "transport": "sse", "defaultRenderJs": true, "maxConcurrentRequests": 5, "defaultProxyGroup": "RESIDENTIAL", "maxPageSizeBytes": 5242880, "defaultTimeout": 30000, "enableSearchTool": true, "rateLimitPerMinute": 60, "allowedDomains": [ "example.com", "docs.mycompany.com" ], "blockedDomains": [ "localhost", "127.0.0.1", "*.internal" ] } ``` # Actor output Schema ## `results` (type: `string`): Actor output data. # API You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup. ## JavaScript example ```javascript import { ApifyClient } from 'apify-client'; // Initialize the ApifyClient with your Apify API token // Replace the '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = { "transport": "sse", "maxConcurrentRequests": 5, "defaultProxyGroup": "RESIDENTIAL", "maxPageSizeBytes": 5242880, "defaultTimeout": 30000, "rateLimitPerMinute": 60 }; // Run the Actor and wait for it to finish const run = await client.actor("junipr/mcp-web-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 '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = { "transport": "sse", "maxConcurrentRequests": 5, "defaultProxyGroup": "RESIDENTIAL", "maxPageSizeBytes": 5242880, "defaultTimeout": 30000, "rateLimitPerMinute": 60, } # Run the Actor and wait for it to finish run = client.actor("junipr/mcp-web-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 '{ "transport": "sse", "maxConcurrentRequests": 5, "defaultProxyGroup": "RESIDENTIAL", "maxPageSizeBytes": 5242880, "defaultTimeout": 30000, "rateLimitPerMinute": 60 }' | apify call junipr/mcp-web-scraper --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "command": "npx", "args": [ "mcp-remote", "https://mcp.apify.com/?tools=junipr/mcp-web-scraper", "--header", "Authorization: Bearer " ] } } } ``` ## OpenAPI specification ```json { "openapi": "3.0.1", "info": { "title": "MCP Web Scraper Server — AI-Ready Web Scraping via MCP", "description": "Model Context Protocol (MCP) server for web scraping. Provides scrape, extract, search, and link discovery tools via SSE or WebSocket transport. Connect AI agents and LLMs to live web data.", "version": "1.0", "x-build-id": "De3yYiMF5b1F8Sl9W" }, "servers": [ { "url": "https://api.apify.com/v2" } ], "paths": { "/acts/junipr~mcp-web-scraper/run-sync-get-dataset-items": { "post": { "operationId": "run-sync-get-dataset-items-junipr-mcp-web-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/junipr~mcp-web-scraper/runs": { "post": { "operationId": "runs-sync-junipr-mcp-web-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/junipr~mcp-web-scraper/run-sync": { "post": { "operationId": "run-sync-junipr-mcp-web-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": { "transport": { "title": "MCP Transport", "enum": [ "sse", "stdio" ], "type": "string", "description": "Transport protocol for MCP communication. 'sse' uses Server-Sent Events for HTTP-based connections (recommended for Apify deployment). 'stdio' uses standard I/O for local testing.", "default": "sse" }, "defaultRenderJs": { "title": "Default JavaScript Rendering", "type": "boolean", "description": "Default setting for JavaScript rendering in scrape_url calls. Agents can override this per call. Disable to reduce compute costs for static sites.", "default": true }, "maxConcurrentRequests": { "title": "Max Concurrent Requests", "minimum": 1, "maximum": 20, "type": "integer", "description": "Maximum number of simultaneous scraping operations. Higher values improve throughput but increase memory usage.", "default": 5 }, "defaultProxyGroup": { "title": "Default Proxy Group", "enum": [ "DATACENTER", "RESIDENTIAL", "NONE" ], "type": "string", "description": "Default Apify proxy group for scraping requests. RESIDENTIAL provides best success rate. DATACENTER is faster and cheaper. NONE disables proxy.", "default": "RESIDENTIAL" }, "maxPageSizeBytes": { "title": "Max Page Size (bytes)", "minimum": 102400, "maximum": 52428800, "type": "integer", "description": "Maximum page size in bytes. Pages larger than this are truncated. Default is 5MB.", "default": 5242880 }, "defaultTimeout": { "title": "Default Request Timeout (ms)", "minimum": 5000, "maximum": 120000, "type": "integer", "description": "Default timeout per request in milliseconds. Agents can override this per call.", "default": 30000 }, "enableSearchTool": { "title": "Enable search_web Tool", "type": "boolean", "description": "Enable the search_web MCP tool. Disable to restrict agents to scraping and extraction only.", "default": true }, "rateLimitPerMinute": { "title": "Rate Limit (calls per minute)", "minimum": 1, "maximum": 600, "type": "integer", "description": "Maximum MCP tool calls per minute across all connected clients. Prevents runaway agents from incurring unexpected costs.", "default": 60 }, "allowedDomains": { "title": "Allowed Domains", "type": "array", "description": "If non-empty, agents can only scrape these domains. Useful for enterprise deployments to restrict scope. Leave empty to allow all non-blocked domains.", "items": { "type": "string" }, "default": [] }, "blockedDomains": { "title": "Blocked Domains", "type": "array", "description": "Domains that agents are not allowed to scrape. Prevents SSRF attacks. The defaults block all localhost and internal network addresses.", "items": { "type": "string" }, "default": [ "localhost", "127.0.0.1", "0.0.0.0", "*.internal", "169.254.169.254" ] } } }, "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 } } } } } } } } } } ```