2026-09-17, updated 2026-10-26, Perplexity · GEO · Fundamentals

Best Perplexity scraper APIs for 2027: answers and sources

Perplexity builds every answer around numbered sources, and the number a user sees is the source’s rank, which makes citation position easy to measure. To collect those answers as JSON you can use a vendor API that returns the consumer answer, call Perplexity’s own API (Sonar, now served through the Agent API), or build your own collector. Perplexity’s API measures something different from what visibility teams need. Scraper APIs differ in what they parse (sources, related queries, the searches Perplexity ran, shopping and local blocks), geo control and billing.

Vendor facts come from the vendors’ own pages, linked and checked on 2026-10-26; “not listed”, “not described” and “not stated” mean not found on those pages on that date. Re-check prices before you commit.

Comparison

Terms used below:

• Source position: the 1-based order in which Perplexity shows a source, which matches the citation number in the answer text.
• Related queries: the follow-up questions Perplexity suggests under an answer, a first-party list of adjacent prompts to add to a tracking set.
• Search fan-out: the searches the engine ran to build the answer, distinct from the related queries it suggests.

Scraper vs Perplexity’s API

Perplexity’s migration guide says Sonar Chat Completions support ended on September 27, 2026. Synchronous and streaming Sonar requests keep working as Agent API requests, rolled out model by model; asynchronous Sonar requests are no longer supported. Perplexity recommends the Agent API for new projects. You pick a model or an effort level (fast, low, medium, high, xhigh) and pay for tokens plus each web search. The answer carries inline [n] markers, and the sources come back as a search_results output item with id, url, title, snippet, date, last_updated and source (web search tool).

Prices checked 2026-10-26 (models, tools, pricing):

The pricing page no longer lists Sonar’s request fees by search context size.

Agent API output differs from the consumer page in three ways:

1. You configure the answer. Model, effort level and search settings are yours, and a consumer user sets none of them, so the output shows how your app would answer.
2. The page has more than the answer. The consumer page can show related queries, shopping cards, places, hotels, images and videos; the Agent API pages checked on 2026-10-26 described none of those.
3. Location is a parameter. The web_search tool accepts a user_location with country, region, city, latitude and longitude. That localizes retrieval for your call, but the call still has the first two differences.

Use the Agent API when you are building a product that needs cited answers, and a scraper when you need to know what Perplexity users see. The provider APIs comparison makes the same distinction for OpenAI and Gemini.

When the Agent API fits

• You are shipping a feature. A support bot, research assistant or internal search tool needs cited answers on demand, under your control and terms.
• You need fixed settings for evaluation. When comparing prompt variants or retrieval filters, pinning the model and search settings is what you want.
• You need to control retrieval. The web_search tool settings, including user_location, shape what is searched.

A team can run both, the Agent API inside the product and consumer answers to measure how the brand appears to Perplexity users. Keep the two in separate datasets and never average them into one visibility number.

The options

Bright Data Perplexity Scraper

Bright Data’s Perplexity Scraper page lists output fields including prompt, answer HTML, answer text, answer text markdown, sources, source HTML and an “is shopping data” flag. Its AI scrapers documentation says each AI scraper takes a prompt and returns the answer with its citations, and links a country list for Perplexity. Requests run synchronously through /scrape (one input recommended; a job longer than 1 minute returns a snapshot_id) or asynchronously through /trigger, with delivery to API, webhook or cloud storage.

Pricing (checked 2026-10-26, Perplexity page): 5K records a month free, $1.50 per 1K records pay as you go, Scale at $499 a month including 384,000 records, then $1.30 per 1K. Only successfully delivered records are billed.

The unit price is low and bulk jobs deliver to storage. The headline fields did not list related queries or local blocks (checked 2026-10-26), so confirm the full schema in its dataset dictionary if you need them, and schemas differ by engine.

Fits data teams running large batch collections into a warehouse.

Oxylabs

The Oxylabs Perplexity target takes source: "perplexity", a prompt, geo_location and parse: true. Per the docs, the parsed response includes the formatted answer, the web sources used, related queries and the UI tabs shown, and product prompts can return inline product cards (inline_products). Jobs use push-pull with an optional callback_url.

Pricing (checked 2026-10-26, pricing): $5 of welcome credit, enough for up to 3,300 Perplexity results; Starter is $30 a month for up to 20,000 Perplexity results. Perplexity has its own line under LLM scrapers at $1.50 per 1K results on every plan up to Flexible ($500 a month), and $1.30 per 1K on Enterprise.

Related queries and product blocks are parsed, with country routing and one subscription across many scraping targets. Oxylabs’ group has owned ScrapingBee since June 2025, and ScrapingBee says it keeps operating as a separate product and entity (Proxyway, ScrapingBee, checked 2026-10-26).

Fits existing Oxylabs customers adding AI engines.

SearchApi

SearchApi’s Perplexity API returns answer markdown with formatted text blocks, reference links with sources and snippets, and related questions, with location-based geo-targeting. New accounts get 100 free requests; Developer is $40 a month for 10,000 searches, down to $1 per 1K at the top tier (pricing).

It is a simple GET API at a flat per-search price, on the same key as its Google engines. The page did not describe shopping, places, hotels or the searches Perplexity ran (checked 2026-10-26).

Fits teams already using SearchApi for SERP data that need Perplexity text plus sources.

Apify Perplexity actors

Apify’s own Perplexity Search Scraper returns the answer text, cited sources with titles, URLs, snippets and dates, and optionally related questions and images, with a countryCode input (default United States) and a recency filter (day, week, month, year). It costs $9.00 per 1,000 searches. Community actors exist at other prices, such as Korado Labs’ Perplexity scraper. Apify’s free plan includes $5 of monthly credit.

It starts without code and integrates with Zapier, Make and Sheets. The official actor page did not mention region or city targeting (checked 2026-10-26), and community actors each have their own schema and upkeep.

Fits prototypes and small studies.

AnswerLine

POST /v1/monitor/perplexity takes prompt, country (any country) and include flags for markdown, rawResponse and html, which links the answer’s public page on perplexity.ai.

curl -X POST https://api.answerline.dev/v1/monitor/perplexity \
  -H "Authorization: Bearer $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "prompt": "Which accounting software do UK freelancers use?",
    "country": "GB",
    "include": { "markdown": true }
  }'

Under result, per the API reference:

• text, and markdown when requested.
• sources[] with position, url, label, description.
• citationPills[] with citationPillId, url, domain, position: the inline chips, one entry per pill-and-source pair.
• related_queries[]: the follow-ups Perplexity suggests.

A Perplexity task costs $0.0015 on every tier, with no per-field add-ons. A new account’s 100 free requests work on any live engine; every tier’s prices are on /pricing. Failed requests are not charged.

The request shape is shared with the ChatGPT, Gemini, Copilot, Grok, AI Mode, Google Search and Google News endpoints, and async batches take up to 500 tasks with webhooks and idempotency keys. Pricing is per request in credits, so a very large one-off census costs less on the lowest per-record vendors.

Fits visibility and GEO products that report citation position and related queries across several assistants.

Building it yourself

Perplexity’s page is dynamic, varies by location and changes layout. A DIY collector needs market-specific collection, a parser for the answer, sources and each rich block, and monitoring for layout changes. The build vs buy post itemizes the work. It makes sense when collection is your core product or you need logged-in states no vendor supports.

Selection criteria

1. If the question is “what do users see”, measure the consumer page, not a configured model.
2. Require ordered sources. Citation share on Perplexity is positional, and URLs pulled from markdown lose the order.
3. Decide whether you need related queries. They expand a prompt set with Perplexity’s own suggestions; see prompt set design.
4. Check local and commerce blocks if you work in travel, hospitality, local services or retail, where places, hotels and shopping cards can outweigh the prose.
5. Confirm geo control at the granularity you report on.
6. Check failure handling and billing: success-only charges, idempotency, webhooks.
7. Price your volume, including markets and cadence.

Cost example

150 prompts, two countries, daily for 30 days: 9,000 Perplexity answers a month. List prices checked 2026-10-26, before discounts. Recurring monthly free allowances (Bright Data’s 5K records, Apify’s $5 credit) are netted; one-time trials are not:

The table omits schema mapping per vendor, a second vendor for engines the first lacks, and analyzes you cannot run when a field is missing. AI monitoring cost planning covers budgeting across engines.

A daily Perplexity citation job on AnswerLine

A daily job looks like this:

import os, datetime, requests

API = "https://api.answerline.dev"
HEADERS = {"Authorization": f"Bearer {os.environ['API_KEY']}"}
today = datetime.date.today().isoformat()

prompts = ["best accounting software for freelancers", "Xero vs QuickBooks for sole traders"]
tasks = [
    {
        "taskType": "PERPLEXITY",
        "payload": {"prompt": p, "country": c},
        "idempotencyKey": f"acct-{i}-{c}-{today}",
        "webhook": {"url": "https://example.com/hooks/perplexity"},
    }
    for i, p in enumerate(prompts)
    for c in ("GB", "IE")
]

r = requests.post(f"{API}/v1/async/task/batch", json=tasks, headers=HEADERS, timeout=30)
r.raise_for_status()
print(r.json()["summary"])

In the webhook handler, read response.result.sources for a COMPLETED task and record your domain’s position:

from urllib.parse import urlparse

def my_position(result, domain="example.com"):
    for s in result.get("sources", []):
        host = urlparse(s["url"]).hostname or ""
        if host == domain or host.endswith("." + domain):
            return s["position"]
    return None

Store None as “not cited” instead of dropping the row, so citation rate has a denominator. Verify webhook signatures before processing.

Perplexity metrics

Define metrics before the first run so the stored data can answer them. The field each uses on AnswerLine:

To keep them comparable over time:

1. Fix the denominator. A failed run is not a run where you were absent. Count completed runs only and log failures separately.
2. Normalize domains once. Decide whether blog.example.com counts as example.com, write it down, and apply it to every engine.
3. Report rates over windows. A seven-day rolling rate smooths run-to-run variation without hiding shifts. The share of voice framework walks through the arithmetic.

Growing the prompt set from related queries

Related queries show which questions sit next to the ones you track:

1. Run your seed prompts for a week.
2. Collect every related_queries[] entry and count how often each appears across runs.
3. Drop queries outside your category and near-duplicates of existing prompts.
4. Add the most frequent survivors as new prompts, tagged “suggested” so you can report them separately from the seed set.
5. Repeat monthly, retiring prompts that never cite anyone in your competitor set.

This keeps the tracking set close to how people move through the topic on Perplexity rather than how a keyword tool phrases it. The prompt set design post covers sizing and balance.

Pitfalls specific to Perplexity data

• Counting domains without position. Source 1 and source 9 are different outcomes.
• Ignoring the pills. Several sources can sit behind one inline chip; citationPills[] records the grouping by citationPillId.
• Single snapshots. Sources change between runs, so trend rates over repeated runs. See AI answer volatility.
• Mixing Agent API (Sonar) and scraped data in one metric. They answer different questions; keep them in separate series.

Perplexity’s fields are listed on the Perplexity engine page, and the Perplexity monitoring tutorial walks through a first integration.

Keep reading