# Perplexity Search Scraper (`automation-lab/perplexity-search-scraper`) Actor

Extract Perplexity AI answers, citations, sources, related questions, and images for public search queries without a Perplexity API key.

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

## Pricing

from $3.72 / 1,000 perplexity query answereds

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/docs.md):

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

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

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

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

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

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

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

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

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


# README

## Perplexity Search Scraper

Run public Perplexity searches at scale and export grounded AI answers with citations—without supplying a Perplexity API key.

Perplexity Search Scraper turns each question into one normalized record containing answer text, ordered citation URLs, rich source metadata, optional related questions, and optional source images.

Use it for repeatable GEO/AEO monitoring, citation audits, competitive intelligence, research snapshots, and agent workflows.

### What does Perplexity Search Scraper do?

This Actor submits questions to Perplexity's public search experience and captures the completed structured response.

It can:

- 🔎 process a list of queries or newline-separated bulk text
- 📝 extract the complete generated answer
- 🔗 preserve citation URLs in Perplexity's source order
- 📚 return source titles, URLs, snippets, dates, domains, and source types
- 💡 include suggested related questions
- 🖼️ include image URLs associated with cited sources
- 📅 limit sources by day, week, month, or year
- 🌍 run the public session from a selected proxy country
- 🧯 isolate failures so one blocked query does not erase valid sibling results
- 📦 export results as JSON, CSV, Excel, XML, or RSS through Apify datasets

No Perplexity account, cookie, Sonar key, or customer-managed browser is required.

### Who is it for?

#### GEO and AEO agencies

Schedule the same brand, category, and comparison questions every week.
Compare how answer wording and cited domains change over time.
Measure whether client pages appear among Perplexity citations.

#### SEO and content teams

Discover which sources Perplexity trusts for a topic.
Collect related questions for content briefs.
Find citation gaps between your site and competitors.

#### Competitive-intelligence teams

Ask consistent market, product, and vendor questions.
Store timestamped answer snapshots in a warehouse.
Diff answers and source lists across runs.

#### Researchers and analysts

Batch grounded questions and retain the answer together with its evidence.
Review source snippets before following citation links.
Export a reproducible research trail.

#### Developers and AI-agent builders

Call Perplexity search as an Apify Actor, scheduled task, webhook step, or MCP tool.
Feed normalized answers and citations into downstream ranking, RAG, alerting, or summarization pipelines.

### Why use this Actor?

- **No Perplexity credential:** users do not need to buy or rotate API keys.
- **Evidence stays attached:** answers and source metadata share one record.
- **Batch ready:** submit up to 100 unique questions in one run.
- **Monitoring friendly:** every record includes a search timestamp and duration.
- **Failure aware:** failed queries produce explicit error records; successful queries still complete.
- **Apify native:** schedule runs, trigger webhooks, export datasets, and integrate through API or MCP.
- **Cost aligned:** charges apply per successfully completed Perplexity answer.

### What Perplexity data can I extract?

| Field | Type | Description |
|---|---|---|
| `query` | string | Submitted Perplexity question |
| `success` | boolean | Whether a complete answer was extracted |
| `answer` | string | Generated answer text |
| `sources` | array | Ordered source objects with metadata |
| `citationUrls` | string[] | Direct citation URLs in source order |
| `relatedQuestions` | string[] | Suggested follow-up questions |
| `images` | object[] | Image URL plus its source link/title |
| `resultUrl` | string | Public Perplexity result URL when available |
| `model` | string | Displayed Perplexity model |
| `searchMode` | string | Search mode returned by Perplexity |
| `searchedAt` | string | ISO extraction timestamp |
| `durationMs` | number | End-to-end query duration |
| `error` | string | Failure reason for an unsuccessful query |

Each `sources` entry can contain `title`, `url`, `snippet`, `date`, `lastUpdated`, `sourceType`, and `domain`.

### How to scrape Perplexity AI answers

1. Open **Perplexity Search Scraper** in Apify Console.
2. Add one or more questions under **Perplexity search queries**.
3. Optionally choose a recency window and proxy country.
4. Enable related questions or source images when needed.
5. Click **Start** and wait for the dataset preview.
6. Export the records or connect the dataset to your workflow.
7. Save the input as an Apify task if you want scheduled snapshots.

Start with one query, inspect the fields, and then scale the batch.

### Input parameters

| Parameter | Type | Default | Purpose |
|---|---|---:|---|
| `queries` | string[] | one sample | Questions entered as a list |
| `queryText` | string | empty | Newline-separated bulk questions |
| `recencyFilter` | enum | none | Restrict web sources to day/week/month/year |
| `countryCode` | string | `US` | Residential session country |
| `includeRelatedQuestions` | boolean | `true` | Retain follow-up suggestions |
| `includeImages` | boolean | `false` | Retain images attached to sources |
| `maxRetries` | integer | `2` | Fresh-session retries per query |
| `delayBetweenQueriesMs` | integer | `1000` | Sequential pacing between questions |

The Actor combines `queries` and `queryText`, trims whitespace, and removes exact duplicates.
At least one non-empty question is required.
A run accepts at most 100 unique questions.

### Example input

```json
{
  "queries": [
    "What is Apify and how does it automate web data workflows?",
    "Which web scraping platforms are best for enterprise teams?"
  ],
  "recencyFilter": "month",
  "includeRelatedQuestions": true,
  "includeImages": false,
  "countryCode": "US",
  "maxRetries": 2,
  "delayBetweenQueriesMs": 1000
}
````

For a copied spreadsheet column, use bulk text:

```json
{
  "queryText": "What is answer engine optimization?\nHow do brands earn Perplexity citations?\nCompare GEO and traditional SEO",
  "includeRelatedQuestions": true
}
```

### Example output

```json
{
  "query": "What is Apify and how does it automate web data workflows?",
  "success": true,
  "answer": "Apify is a cloud platform for web scraping and automation...",
  "sources": [
    {
      "title": "Apify platform documentation",
      "url": "https://docs.apify.com/",
      "snippet": "Documentation for the Apify platform...",
      "sourceType": "web",
      "domain": "docs.apify.com"
    }
  ],
  "citationUrls": ["https://docs.apify.com/"],
  "relatedQuestions": ["What are Apify Actors?"],
  "resultUrl": "https://www.perplexity.ai/search/...",
  "model": "turbo",
  "searchMode": "SEARCH",
  "searchedAt": "2026-07-21T06:25:58.615Z",
  "durationMs": 12042
}
```

Answers are non-deterministic and source availability changes.
That is why scheduled snapshots are useful.

### How much does it cost to scrape Perplexity searches?

The Actor uses pay-per-event pricing:

- a small **$0.005 run-start** charge
- a tiered charge per successful query
- current BRONZE reference: **$0.0062004 per completed answer**
- failed queries are not charged as successful answers

At the BRONZE reference, one query is about $0.0112 including run start, while ten successful queries are about $0.0670.
Higher Apify plans receive lower per-query tier prices.
Always check the live pricing panel for your plan before a large batch.

### GEO and AEO monitoring workflow

Create a stable question set such as:

- “What are the best payroll tools for small businesses?”
- “Is Brand X suitable for distributed teams?”
- “Compare Brand X and Brand Y.”
- “Which sources explain category Z most clearly?”

Schedule the task daily or weekly.
Join records by `query` and compare `citationUrls` over time.
Alert when a client domain appears, disappears, or changes rank.
Store answer text for qualitative review.

### Citation and source analysis tips

- Treat `citationUrls` as ordered evidence, not proof that every URL is quoted equally.
- Use `sources[].domain` for share-of-citation aggregation.
- Keep `searchedAt` when merging datasets.
- Compare multiple neutral prompt formulations to reduce prompt wording bias.
- Review source snippets before making content or compliance decisions.
- Use recency filters only when freshness is part of the question.

### Reliability and retry behavior

Perplexity protects its public experience with anti-abuse controls.
The Actor uses fresh residential sessions, anonymous cookie/CSRF bootstrap, conservative sequential pacing, and bounded retries.

A successful query is charged and saved immediately.
A query that exhausts retries creates `success: false` with an `error` field.
If every query fails, the Actor exits non-zero rather than reporting a misleading successful run.

For stable batches:

- keep the default delay initially
- avoid repeating the same question hundreds of times
- use batches of related but distinct questions
- increase retries only when logs show transient session blocks
- schedule large monitoring sets across reasonable intervals

### Integrations

#### Google Sheets

Send the default dataset to a spreadsheet.
Use one row per query snapshot and extract source domains for reporting.

#### Slack or email alerts

Trigger a webhook after each run.
Compare citations with the prior dataset and notify a channel when a tracked domain changes.

#### Make and Zapier

Start the Actor from a new keyword row or campaign record.
Route successful answers to a database and failed rows to a retry queue.

#### Snowflake, BigQuery, and warehouses

Export JSON records with `query` and `searchedAt` as snapshot keys.
Normalize `sources` in downstream SQL when you need one row per citation.

#### RAG and agent pipelines

Use the answer as grounded context and retain citation URLs as provenance.
Apply your own trust, freshness, or domain filters before model ingestion.

### API usage with JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/perplexity-search-scraper').call({
  queries: ['What is answer engine optimization?'],
  includeRelatedQuestions: true,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items[0].citationUrls);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("automation-lab/perplexity-search-scraper").call(run_input={
    "queries": ["What is answer engine optimization?"],
    "includeRelatedQuestions": True,
})
items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items[0]["citationUrls"])
```

### API usage with cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~perplexity-search-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"queries":["What is answer engine optimization?"],"includeRelatedQuestions":true}'
```

Fetch dataset items after the run finishes:

```bash
curl "https://api.apify.com/v2/datasets/DATASET_ID/items?clean=true&format=json"
```

### Use Perplexity Search Scraper with MCP

Connect the Actor to Claude Code:

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

For Claude Desktop, Cursor, or VS Code, add:

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

Example prompts:

- “Run the Perplexity scraper for these five brand-comparison questions and summarize cited domains.”
- “Check whether example.com appears in Perplexity citations for our category questions.”
- “Collect fresh Perplexity answers from the past month and save the dataset link.”

### Scheduling recurring snapshots

Save a tested input as an Apify task.
Choose a daily, weekly, or monthly schedule.
Use a webhook to send the dataset ID to your analysis system.

Keep question wording stable when measuring changes.
Version your query set when prompts change.
Avoid overwriting old datasets if historical comparison matters.

### Export formats

The Apify dataset supports:

- JSON for applications and nested source objects
- CSV or Excel for analyst review
- XML for legacy systems
- RSS for lightweight monitoring
- API pagination for larger batches

JSON preserves nested `sources` and `images` most accurately.
For CSV, nested arrays are serialized into cells.

### Limitations

- Perplexity answers and citations can change between identical runs.
- Public-session capacity and anti-abuse rules may change.
- V1 supports anonymous concise search, not authenticated Pro or deep-research modes.
- A recency filter influences source retrieval but does not guarantee every cited page exposes a date.
- Image URLs can expire or be served by third-party CDNs.
- Source metadata reflects what Perplexity returns; it is not independently fact-checked.
- The Actor processes queries sequentially for reliability rather than maximum concurrency.
- This tool is not the official Perplexity API.

### Responsible and legal use

The Actor extracts publicly returned search answers and citation metadata.
Use it in accordance with applicable laws, contractual obligations, and platform terms.
Do not use outputs to collect sensitive personal data, misrepresent generated answers as verified facts, or evade access controls.

Generated answers may contain mistakes.
Review important claims against cited primary sources.
Respect copyright and attribution requirements when republishing text or source snippets.

### Troubleshooting

#### Why did a query return `success: false`?

Open the run log and inspect the error field.
A public session may have been rate-limited or served an authentication prompt after all retries.
Try a smaller batch, retain the default delay, or rerun later.

#### Why did the whole run fail?

The Actor fails when input has no non-empty queries or when every query failed extraction.
This fail-closed behavior prevents empty or anti-abuse pages from looking like valid data.

#### Why are some source dates missing?

Perplexity does not return a date for every source.
The Actor omits unavailable dates rather than inventing values.

#### Why are there no images?

Enable `includeImages`.
Even then, only images attached to returned source metadata can be exported.

### FAQ

#### Do I need a Perplexity API key?

No.
The Actor uses the public anonymous Perplexity search workflow.
You only need an Apify account and token for API-based Actor runs.

#### Can I submit questions in bulk?

Yes.
Use the query list or paste one query per line into `queryText`.
The limit is 100 unique queries per run.

#### Does the Actor keep citation order?

Yes.
`sources` and `citationUrls` follow the order returned in the completed Perplexity response.

#### Are failed queries charged?

The successful-query event is emitted only after a complete answer is extracted and saved.
The small run-start fee still applies.

#### Can I monitor brands over time?

Yes.
Scheduled, non-deterministic snapshots are a primary use case.
Store `query`, `searchedAt`, `answer`, and `citationUrls` for comparisons.

#### Can this run Pro or Deep Research?

Not in V1.
Those modes require authenticated or paid capabilities and are intentionally excluded from this anonymous public-data product.

### Related Automation Labs scrapers

- [Google Search Scraper](https://apify.com/automation-lab/google-search-scraper) — collect organic SERP results, People Also Ask, and related searches.
- [Google Trends Scraper](https://apify.com/automation-lab/google-trends-scraper) — monitor changing search interest and related topics.

Combine traditional SERP evidence with Perplexity citation snapshots for a broader search-visibility view.

### Support

If a run behaves unexpectedly, share the Apify run URL and a minimal non-sensitive input through the Actor issue form.
Include whether the failure affects all queries or only a specific prompt/country.
That evidence helps reproduce public-session changes quickly.

# Actor input Schema

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

Questions to submit to Perplexity. Each query produces one normalized dataset record.

## `queryText` (type: `string`):

Optional newline-separated queries. These are combined with and deduplicated against the query list above.

## `recencyFilter` (type: `string`):

Optionally limit Perplexity web sources by publication recency.

## `countryCode` (type: `string`):

Two-letter ISO country code used for the Perplexity session, such as US, GB, DE, or CA.

## `includeRelatedQuestions` (type: `boolean`):

Include Perplexity follow-up question suggestions in each output record.

## `includeImages` (type: `boolean`):

Collect image URLs attached to cited Perplexity sources when available.

## `maxRetries` (type: `integer`):

Retry a query with a fresh residential proxy session after anti-abuse or transient failures.

## `delayBetweenQueriesMs` (type: `integer`):

Pause between sequential queries to reduce rate limiting.

## Actor input object example

```json
{
  "queries": [
    "What is Apify and how does it help automate web data workflows?"
  ],
  "queryText": "",
  "countryCode": "US",
  "includeRelatedQuestions": true,
  "includeImages": false,
  "maxRetries": 2,
  "delayBetweenQueriesMs": 1000
}
```

# 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 = {
    "queries": [
        "What is Apify and how does it help automate web data workflows?"
    ],
    "countryCode": "US",
    "maxRetries": 2,
    "delayBetweenQueriesMs": 1000
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/perplexity-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 = {
    "queries": ["What is Apify and how does it help automate web data workflows?"],
    "countryCode": "US",
    "maxRetries": 2,
    "delayBetweenQueriesMs": 1000,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/perplexity-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 '{
  "queries": [
    "What is Apify and how does it help automate web data workflows?"
  ],
  "countryCode": "US",
  "maxRetries": 2,
  "delayBetweenQueriesMs": 1000
}' |
apify call automation-lab/perplexity-search-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Perplexity Search Scraper",
        "description": "Extract Perplexity AI answers, citations, sources, related questions, and images for public search queries without a Perplexity API key.",
        "version": "0.1",
        "x-build-id": "2ScTx8hgiWDQQpy97"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~perplexity-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-perplexity-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~perplexity-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-perplexity-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~perplexity-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-perplexity-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": {
                    "queries": {
                        "title": "Perplexity search queries",
                        "type": "array",
                        "description": "Questions to submit to Perplexity. Each query produces one normalized dataset record.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "queryText": {
                        "title": "Bulk queries (one per line)",
                        "type": "string",
                        "description": "Optional newline-separated queries. These are combined with and deduplicated against the query list above.",
                        "default": ""
                    },
                    "recencyFilter": {
                        "title": "Search recency",
                        "enum": [
                            "day",
                            "week",
                            "month",
                            "year"
                        ],
                        "type": "string",
                        "description": "Optionally limit Perplexity web sources by publication recency."
                    },
                    "countryCode": {
                        "title": "Proxy country code",
                        "minLength": 2,
                        "maxLength": 2,
                        "type": "string",
                        "description": "Two-letter ISO country code used for the Perplexity session, such as US, GB, DE, or CA.",
                        "default": "US"
                    },
                    "includeRelatedQuestions": {
                        "title": "Include related questions",
                        "type": "boolean",
                        "description": "Include Perplexity follow-up question suggestions in each output record.",
                        "default": true
                    },
                    "includeImages": {
                        "title": "Include source images",
                        "type": "boolean",
                        "description": "Collect image URLs attached to cited Perplexity sources when available.",
                        "default": false
                    },
                    "maxRetries": {
                        "title": "Retries per query",
                        "minimum": 0,
                        "maximum": 4,
                        "type": "integer",
                        "description": "Retry a query with a fresh residential proxy session after anti-abuse or transient failures.",
                        "default": 2
                    },
                    "delayBetweenQueriesMs": {
                        "title": "Delay between queries (milliseconds)",
                        "minimum": 0,
                        "maximum": 30000,
                        "type": "integer",
                        "description": "Pause between sequential queries to reduce rate limiting.",
                        "default": 1000
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```