# Perplexity AI Search Scraper (`zhorex/perplexity-ai-scraper`) Actor

Search Perplexity AI programmatically. Get AI-generated answers with sources and citations. No API key needed. The only Perplexity scraper on Apify that works without your own API key. Built for AEO and brand monitoring. Fast, clean JSON output.

- **URL**: https://apify.com/zhorex/perplexity-ai-scraper.md
- **Developed by:** [Sami](https://apify.com/zhorex) (community)
- **Categories:** AI, Lead generation, SEO tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.00 / 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

## Perplexity AI Search Results Scraper

The **ONLY** Perplexity AI search results scraper on Apify. **No API key needed.** Extract AI-generated answers, cited sources, and related questions directly from the Perplexity web interface.

Built for **Answer Engine Optimization (AEO)** and brand monitoring.

### How to scrape Perplexity AI in 3 easy steps

1. **Go to [Perplexity AI Scraper](https://apify.com/zhorex/perplexity-ai-scraper)** on Apify Store and click **"Try for free"**
2. **Enter your search queries** — type any question or keyword you want Perplexity to answer
3. **Click Run** and download AI-generated answers with cited sources in JSON, CSV, or Excel

No API key required. No coding needed. Works with Apify's free plan.

### Why this actor?

Every other "Perplexity" actor on Apify requires YOUR Perplexity API key. This one doesn't -- it scrapes the public web interface directly using a headless browser, just like a real user would.

### Perplexity API alternative — no API key needed

Perplexity offers an official API (Sonar), but it requires a paid subscription and API key. This Actor is the best Perplexity API alternative in 2026 — it extracts the same AI-generated answers, sources, and citations directly from the free public web interface.

Perfect for teams who need Perplexity data at scale without managing API keys or paying for Sonar Pro.

### What is Answer Engine Optimization (AEO)?

Answer Engine Optimization (AEO) is the practice of optimizing your content to appear in AI-generated answers from search engines like Perplexity, ChatGPT, Google AI Overviews, and Claude. Unlike traditional SEO (optimizing for blue links), AEO focuses on getting your brand mentioned and cited in AI answers.

This Actor helps you monitor your AEO performance by tracking how Perplexity answers queries related to your brand, products, and industry.

### Two modes of operation

#### Mode 1: `search` -- Extract full answers

Input:
```json
{
  "mode": "search",
  "queries": [
    "best CRM software for small business 2026",
    "top project management tools for startups"
  ]
}
````

Output per query:

```json
{
  "query": "best CRM software for small business 2026",
  "answer": "For 2026, the best CRM overall is Zoho CRM for most small and midsize businesses...",
  "sources": [
    {
      "position": 1,
      "title": "The Best CRM Software for 2026",
      "url": "https://www.pcmag.com/picks/the-best-crm-software",
      "domain": "pcmag.com",
      "snippet": "Customers are vital to any business..."
    }
  ],
  "relatedQuestions": [
    "Zoho CRM vs Salesforce which is better for small businesses",
    "Best free or low-cost CRM alternatives for startups 2026"
  ],
  "totalSources": 10,
  "answerLength": 1542,
  "searchUrl": "https://www.perplexity.ai/search?q=best+CRM+software+for+small+business+2026",
  "scrapedAt": "2026-04-09T15:00:00+00:00"
}
```

#### Mode 2: `brand_monitor` -- Track brand mentions in AI answers

Input:

```json
{
  "mode": "brand_monitor",
  "brandName": "HubSpot",
  "queries": [
    "best CRM software 2026",
    "top email marketing platforms for ecommerce"
  ]
}
```

Output per query:

```json
{
  "brand": "HubSpot",
  "query": "best CRM software 2026",
  "mentioned": true,
  "mentionContext": "HubSpot is the easiest all-around option for teams that want a simple start and strong marketing tie-ins.",
  "position": "Mentioned early in the answer (top section)",
  "competitorsMentioned": ["Zoho CRM", "Salesforce", "Pipedrive", "Klaviyo"],
  "sourcesCount": 10,
  "scrapedAt": "2026-04-09T15:00:00+00:00"
}
```

### Use cases

- **AEO (Answer Engine Optimization)** -- Monitor how AI search engines talk about your brand. Track whether Perplexity recommends you, your competitors, or neither.
- **Competitive intelligence** -- See which competitors Perplexity recommends for your target keywords and how they're positioned.
- **Content strategy** -- Discover what sources Perplexity cites for your target keywords. If your content isn't cited, you know what to improve.
- **Market research** -- Get AI-curated answers to research questions at scale, with full source attribution.

### Scrape Perplexity with Python, JavaScript, or no code

Use this Actor directly from the Apify platform (no coding required), or call it via the [Apify API](https://docs.apify.com/api) from Python, JavaScript, or any language:

**Python example:**

```python
from apify_client import ApifyClient
client = ApifyClient("YOUR_API_TOKEN")
run = client.actor("zhorex/perplexity-ai-scraper").call(run_input={
    "mode": "search",
    "queries": ["best CRM software 2026"]
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["answer"])
```

**JavaScript example:**

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });
const run = await client.actor('zhorex/perplexity-ai-scraper').call({
    mode: 'search',
    queries: ['best CRM software 2026'],
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items[0].answer);
```

### Input parameters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `mode` | string | `search` | `search` or `brand_monitor` |
| `queries` | string\[] | required | List of search queries |
| `brandName` | string | -- | Brand name (required for `brand_monitor`) |
| `maxQueries` | integer | 10 | Max queries to process (1-100) |
| `waitTimeout` | integer | 60 | Max seconds to wait per answer (15-120) |
| `proxyConfiguration` | object | Apify proxy | Proxy settings |

### Pricing

**$0.02 per query** ($20 per 1,000 queries).

This is AI-curated intelligence with full source attribution, not raw HTML scraping.

### How it works

1. Opens Perplexity.ai in a headless Chromium browser (Playwright)
2. Navigates directly to the search URL for each query
3. Waits for the AI to finish generating its answer (streaming detection)
4. Extracts the full answer text, cited sources with URLs, and related questions
5. Pushes structured results to the Apify dataset

### Performance

- **Speed**: ~15-30 seconds per query (AI answer generation takes time)
- **Memory**: 1024 MB recommended (Playwright + Chromium)
- **Concurrency**: Sequential queries with 5s delay to avoid rate limiting

### Limitations

- **Rate limiting**: Perplexity may rate-limit at high volume. Use proxy rotation for large batches.
- **Non-deterministic**: AI answers may vary between runs -- the same query can produce different answers.
- **UI changes**: Perplexity's interface may change, requiring actor updates. We monitor and update regularly.
- **Slower than API**: ~15-30 seconds per query due to browser rendering and streaming wait time. API wrappers are faster but require your own API key.
- **No login features**: This actor uses Perplexity's free, unauthenticated interface.

### FAQ

**How do I scrape Perplexity AI answers?**
Use this Actor on Apify — enter your search queries, click Run, and get structured AI answers with cited sources. No API key, no coding required.

**Is there a free Perplexity API?**
Perplexity's official API (Sonar) requires a paid subscription. This Actor is the best free alternative — it scrapes the public web interface without any API key. Start with Apify's free plan ($5/month included).

**How much does it cost to scrape Perplexity?**
$0.02 per query ($20 per 1,000 queries). You can test with Apify's free tier which gives you $5 of monthly usage — enough for 250 queries.

**Can I use this for brand monitoring across AI search engines?**
Yes. Use `brand_monitor` mode to track whether Perplexity mentions your brand in answers. Combine with scheduled runs (daily, weekly) for continuous monitoring. For comprehensive AI brand monitoring across ChatGPT, Claude, and Gemini, pair this with other AI scrapers.

**How is this different from the Perplexity API?**
The official Perplexity API (Sonar) gives programmatic access but requires a paid API key. This Actor scrapes the free public web interface — same answers, same sources, no API key required. Trade-off: slower (~15-30s per query) but free to access.

**What is AEO and why does it matter?**
Answer Engine Optimization (AEO) is the practice of getting your brand mentioned in AI search results. As more users shift from Google to AI search engines like Perplexity, monitoring your AI search visibility becomes critical for marketing strategy.

### Integrations & data export

Export your Perplexity data in JSON, CSV, Excel, or XML. Integrate directly with:

- **Google Sheets** — automatic AEO monitoring dashboards
- **Zapier / Make / n8n** — workflow automation and alerts when brand mentions change
- **REST API** — programmatic access from Python, JavaScript, or any language
- **Webhooks** — real-time notifications when scrapes complete
- **Slack / Email** — automated alerts for brand visibility changes

[See all integrations →](https://docs.apify.com/platform/integrations)

### Legal

This actor accesses Perplexity's publicly available search interface. No login or authentication is used. It operates the same way a regular user would interact with the website through a browser.

### More actors by Zhorex

**AI & SEO Tools:**

- [Domain Authority Checker](https://apify.com/zhorex/domain-authority-checker) — Bulk DA, DNS & SEO audit
- [Tech Stack Detector](https://apify.com/zhorex/tech-stack-detector) — BuiltWith alternative

**B2B Review Intelligence:**

- [G2 Reviews Scraper](https://apify.com/zhorex/g2-reviews-scraper) — B2B software reviews via public API (no proxy)
- [Capterra Reviews Scraper](https://apify.com/zhorex/capterra-reviews-scraper) — Software reviews with ratings

**Chinese Social Intelligence Suite:**

- [RedNote Xiaohongshu Scraper](https://apify.com/zhorex/rednote-xiaohongshu-scraper) — China's #1 lifestyle platform
- [Weibo Scraper](https://apify.com/zhorex/weibo-scraper) — China's Twitter (580M+ users)
- [Bilibili Scraper](https://apify.com/zhorex/bilibili-scraper) — China's YouTube (300M+ users)

**Other Tools:**

- [Telegram Channel Scraper](https://apify.com/zhorex/telegram-channel-scraper) — Telegram messages and media
- [Kick.com Scraper](https://apify.com/zhorex/kick-scraper) — Kick streamer analytics
- [Phone Number Validator](https://apify.com/zhorex/phone-number-validator) — Validate and format phone numbers

***

💡 **Found this Actor useful?** Please [leave a star rating](https://apify.com/zhorex/perplexity-ai-scraper) — it helps other users discover this tool.

# Actor input Schema

## `mode` (type: `string`):

Operation mode: 'search' extracts full answers and sources, 'brand\_monitor' checks if a brand is mentioned in answers.

## `queries` (type: `array`):

List of queries to search on Perplexity AI. Each query will produce one result.

## `brandName` (type: `string`):

Brand name to check for mentions in Perplexity answers. Only used in 'brand\_monitor' mode.

## `maxQueries` (type: `integer`):

Maximum number of queries to process from the list. Use to limit costs during testing.

## `waitTimeout` (type: `integer`):

How long to wait for Perplexity to finish generating each answer. Increase for complex queries.

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

Apify proxy settings. Datacenter proxy recommended for reliability. Required for high volume.

## Actor input object example

```json
{
  "mode": "search",
  "queries": [
    "best CRM software 2026",
    "top project management tools for startups"
  ],
  "maxQueries": 10,
  "waitTimeout": 60,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# 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 = {
    "queries": [
        "best CRM software 2026",
        "top project management tools for startups"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("zhorex/perplexity-ai-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 = {
    "queries": [
        "best CRM software 2026",
        "top project management tools for startups",
    ],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("zhorex/perplexity-ai-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 '{
  "queries": [
    "best CRM software 2026",
    "top project management tools for startups"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call zhorex/perplexity-ai-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Perplexity AI Search Scraper",
        "description": "Search Perplexity AI programmatically. Get AI-generated answers with sources and citations. No API key needed. The only Perplexity scraper on Apify that works without your own API key. Built for AEO and brand monitoring. Fast, clean JSON output.",
        "version": "1.0",
        "x-build-id": "DefLhzjQi6SMy7BWT"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/zhorex~perplexity-ai-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-zhorex-perplexity-ai-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/zhorex~perplexity-ai-scraper/runs": {
            "post": {
                "operationId": "runs-sync-zhorex-perplexity-ai-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/zhorex~perplexity-ai-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-zhorex-perplexity-ai-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": [
                    "queries"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search",
                            "brand_monitor"
                        ],
                        "type": "string",
                        "description": "Operation mode: 'search' extracts full answers and sources, 'brand_monitor' checks if a brand is mentioned in answers.",
                        "default": "search"
                    },
                    "queries": {
                        "title": "Search queries",
                        "type": "array",
                        "description": "List of queries to search on Perplexity AI. Each query will produce one result.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "brandName": {
                        "title": "Brand to monitor",
                        "type": "string",
                        "description": "Brand name to check for mentions in Perplexity answers. Only used in 'brand_monitor' mode."
                    },
                    "maxQueries": {
                        "title": "Max queries to process",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum number of queries to process from the list. Use to limit costs during testing.",
                        "default": 10
                    },
                    "waitTimeout": {
                        "title": "Max seconds to wait for each answer",
                        "minimum": 15,
                        "maximum": 120,
                        "type": "integer",
                        "description": "How long to wait for Perplexity to finish generating each answer. Increase for complex queries.",
                        "default": 60
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify proxy settings. Datacenter proxy recommended for reliability. Required for high volume."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```