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

{
  "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:

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

Example output

{
  "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

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

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

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:

$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:

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

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

{
  "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 — collect organic SERP results, People Also Ask, and related searches.
• 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.