2026-09-17, Perplexity · GEO · Fundamentals

Best Perplexity scraper APIs: answers and sources as JSON

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 Sonar API, or build your own collector. Sonar 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-09-17. 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 Sonar

Perplexity’s Sonar API lets you pick a model (sonar, sonar-pro, sonar-reasoning-pro, sonar-deep-research) and a search context size, and bills tokens plus a per-request fee. Its search context guide says responses include citations (the URLs that supported the answer) and search results with title, URL, date, snippet and source, delivered in the final chunks when streaming.

Prices checked 2026-09-17:

Perplexity also lists a Search API at $5 per 1,000 requests, which returns search results without a written answer.

Sonar output differs from the consumer page in three ways:

1. You configure the answer. Model, context size and prompt 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 Sonar pages checked describe none of those.
3. Location is a parameter. Sonar’s search filters accept a user_location with country, region, city and coordinates. That localizes retrieval for your call, but the call still has the first two differences.

Use Sonar 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 Sonar is the better tool

• 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 context size is what you want.
• You need to control retrieval. Sonar’s search filters, including user_location, shape what is searched.

A team can run both, Sonar 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 describes Perplexity as returning hyperlinked citations with available countries. Requests run synchronously through /scrape (up to 20 inputs) or asynchronously through /trigger, with delivery to API, webhook or cloud storage.

Pricing (checked 2026-09-17, ChatGPT scraper page and 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 do not list related queries or local blocks, 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 shopping results and inline product listings. Jobs use push-pull with an optional callback_url.

Pricing (checked 2026-09-17, pricing): free trial up to 2,000 results; Micro is $49 a month for up to 98,000 results. Per-1K rates vary by target type, and LLM sources are not a separate line on the pricing page, so confirm the rate with Oxylabs.

Related queries and product blocks are parsed, with country routing and one subscription across many scraping targets.

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 does not describe shopping, places, hotels or the searches Perplexity ran.

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 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. Location control is not stated on the official actor page, and community actors each have their own schema and upkeep.

Fits prototypes and small studies.

AnswerLine

POST /v1/monitor/perplexity takes prompt, country, an optional state for US states, and include flags for markdown, html and rawResponse.

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.
• search_model_queries[]: the searches it ran.
• shopping_cards[] (products with price, merchant, offers, rating), places[] (name, address, coordinates, rating), hotels[] (rating, price level, address), images[] and videos[], when the page shows them.

A Perplexity task costs 4 credits async and 6 synchronous, with no per-field add-ons. The free tier is 500 credits a month without a card; plan prices are on /pricing. Failed requests are not charged.

Local and travel blocks are parsed alongside sources, which matters for hospitality and local-service brands. The request shape is shared across eight engines, async batches take up to 500 tasks with webhooks and idempotency keys, and US states can be targeted. 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, local presence or product placement 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-09-17, before discounts:

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

A daily Perplexity citation job on AnswerLine

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