2026-09-17, ChatGPT · GEO · Fundamentals

Best ChatGPT scraper APIs: answers and citations as JSON

To get what ChatGPT tells users, with the pages it cites, as JSON, there are three routes: a scraper API that collects and parses the consumer answer, OpenAI’s developer API with its web search tool, or your own collector. Only the first and third return the consumer answer. Scraper APIs differ in which parts of the answer they parse (citations, the searches ChatGPT ran, shopping cards, ads), how you target a market, and how you pay.

Facts about each vendor come from its own public pages, linked and checked on 2026-09-17. Re-check prices before you commit.

Comparison

Two terms used below:

• Citation: a source the answer links to, in the order the interface shows it. A mention is a brand named in the text without a link. See mentions vs citations.
• Query fan-out: the rewritten web searches ChatGPT runs before answering; its cited sources come from what those searches return. See query fan-out.

What to measure first

Decide the metrics before comparing vendors. Each depends on a specific part of the response:

1. Mention rate: does the answer name your brand? Needs clean answer text, which every option provides.
2. Citation share: is your domain among the sources, and at what position? Needs a sources array in display order, not URLs pulled out of the markdown.
3. Retrieval analysis: which searches fed the answer? Needs the fan-out queries. Without them you see which pages won but not on which query.
4. Commerce visibility: did a product card show your SKU, at what price, from which merchant? Needs parsed shopping blocks.
5. Market variation: does the answer differ in Germany, or in Texas? Needs country, and sometimes sub-country, targeting.

For the first metric almost any option works, including a cheap actor. Metrics three to five narrow the list to a few vendors.

The options

Bright Data ChatGPT Scraper

Bright Data sells AI scrapers as part of its Web Scraper API. Its product page lists ChatGPT output fields including prompt, answer HTML, answer text, links attached, citations, recommendations and country, with sibling scrapers for Google AI Mode, Perplexity, Gemini and Bing Copilot. Its AI scrapers documentation says ChatGPT supports citations, follow-up prompts and detection of shopping and map results, and takes a web_search input with a web_search_triggered output confirming whether a search ran. The same page marks Grok as currently unavailable.

A synchronous /scrape call handles up to 20 inputs and returns HTTP 202 with a snapshot_id if it times out; an asynchronous /trigger handles large jobs, with delivery by API, webhook or cloud storage.

Pricing (checked 2026-09-17): 5K records a month free, $1.50 per 1K records pay as you go, a Scale plan at $499 a month with 384,000 records and $1.30 per 1K beyond. Only successfully delivered records are billed.

Each engine is a separate scraper with its own output fields, so you write a mapping per engine, and async jobs return snapshots you collect later.

Fits data teams already on Bright Data, or buyers who want bulk datasets delivered to storage.

DataForSEO LLM Scraper

DataForSEO’s AI Optimization API contains four products; two are relevant. LLM Scraper collects ChatGPT and Gemini results as users see them. LLM Responses calls the official model APIs of ChatGPT, Gemini, Claude and Perplexity, which measures something different (see the OpenAI section below).

The ChatGPT LLM Scraper live advanced endpoint takes a keyword, a location, a language and an optional force_web_search, and returns markdown, sources (the references cited), search_results (everything retrieved), fan_out_queries, brand_entities, and typed items including chat_gpt_products, chat_gpt_local_businesses and chat_gpt_ad.

Pricing (checked 2026-09-17): per results page, $0.0012 in the standard queue (up to 45 minutes), $0.0024 in the priority queue (up to 5 minutes), $0.004 live (up to 90 seconds). The AI optimization page states a $50 minimum top-up and that credits never expire; new accounts get $1 of trial credit.

It has the lowest list price per answer on this page, with fan-out, brand entities and products in the schema. The scraper side covers two engines. The cheapest price is a queue with turnaround in minutes, and live use costs about three times as much. The response follows DataForSEO’s SERP-style item model (rank_group, rank_absolute), which suits SEO tooling and needs mapping elsewhere.

Fits SEO platforms already built on DataForSEO that want ChatGPT and Gemini data at the lowest unit price and can tolerate queue latency.

Oxylabs Web Scraper API

The ChatGPT target docs describe source: "chatgpt" with a prompt (under 4,000 characters), search: true for web search (default false), geo_location for the country, and parse: true for structured output. Parsed fields: response_text, markdown_text, markdown_json, citations, search_queries, links, shopping_products, ads and llm_model. Results use Oxylabs’ push-pull model with an optional callback_url, and separate targets exist for Perplexity, Gemini and Google AI Mode.

Pricing (checked 2026-09-17, pricing page): a free trial of up to 2,000 results; Micro is $49 a month for up to 98,000 results. The page lists per-1K rates by target type, with JavaScript results at $1.35 per 1K on Micro; the ChatGPT docs say JavaScript rendering is on by default for all LLM sources, so confirm which rate applies before modelling cost.

Fan-out, citations, products and ads come in one parsed result, with callbacks. Web search is off unless you set search, which changes what you measure if you forget it. Plans are subscriptions with rates that vary by target.

Fits teams already using Oxylabs for other scraping who want AI engines under the same contract.

SearchApi

SearchApi’s ChatGPT API, per its page, returns the reply as Markdown and typed text blocks, reference links with title, URL, source, snippet and publish date, inline citations mapped by character position, the web search queries ChatGPT ran, and entity cards. It also lists Perplexity, Gemini, Bing Copilot, Google AI Mode and Google AI Overview APIs.

Pricing (checked 2026-09-17, pricing): 100 free requests; Developer is $40 a month for 10,000 searches ($4 per 1K), falling to $1 per 1K at the 5M tier. The ChatGPT page says you pay only for successful answers.

Requests are simple GETs at a flat per-search price, with fan-out and positional citations. The ChatGPT page does not describe shopping cards or ads, and tiers commit you to a monthly volume.

Fits teams already using SearchApi for Google results who want ChatGPT under the same key.

Apify Store actors

Apify is a marketplace, so “ChatGPT scraper” covers several actors with different owners and prices. Apify’s own ChatGPT Search Scraper returns text, sources, queryFanOut and widgets (such as product listings), priced from $3.00 per 1,000 searches per event, lower on higher Apify subscriptions. Community actors exist too; Korado Labs’ ChatGPT Search Scraper charges $0.15 per answer and adds brand mention checks. Apify’s free plan includes $5 of monthly platform credit; Starter is $19 a month.

Actors are quick to try from a UI, integrate with Zapier, Make and Google Sheets, and bill per result. Each actor has its own schema, maintainer and failure modes, so switching actors means remapping fields, and prices vary widely: the two ChatGPT actors above are $3.00 and $150.00 per 1,000 answers.

Fits prototypes, one-off studies and no-code teams.

ScrapingBee ChatGPT API

ScrapingBee’s ChatGPT API returns results_markdown, results_text, results_json and llm_model, with search=true for web search and country_code for geolocation. Its documentation says it is “not able to return citations 100% of the time”, and citations, when present, appear in the markdown or HTML rather than a dedicated sources array.

Pricing (checked 2026-09-17): 15 credits per successful call; 1,000 free trial credits; Hobby is $19 a month for 75,000 credits, or 5,000 ChatGPT calls.

It is convenient if you already use ScrapingBee. The documentation has no structured sources, fan-out or shopping fields, so citation share needs your own parsing and will have gaps.

Fits collecting answer text for qualitative review rather than citation measurement.

AnswerLine

AnswerLine has one endpoint per engine. POST /v1/monitor/chatgpt takes a prompt and a country and returns the ChatGPT answer parsed into fields.

curl -X POST https://api.answerline.dev/v1/monitor/chatgpt \
  -H "Authorization: Bearer $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "prompt": "What is the best CRM for a 20-person agency?",
    "country": "US",
    "include": { "markdown": true, "searchQueries": true, "shopping": true }
  }'

Fields under result, per the API reference:

• text and, when requested, markdown.
• sources[]: each with position, url, label, description, datePublished, and footnote for sources that appear only in the sources list.
• citationPills[]: the inline citation chips, one entry per pill-and-source pair, grouped by citationPillId.
• searchQueries[]: the query fan-out, when include.searchQueries is true.
• shoppingCards[] and inlineProducts[]: products with price, merchant, rating and offers, when include.shopping is true.
• ads[]: sponsored units with a rendered flag, when include.ads is true.
• entities[] and map[].

Web search is forced by default; disableWebSearch: true returns the answer ChatGPT gives on its own, where sources and searchQueries are often empty. state takes a two-letter US state code with country: "US".

A ChatGPT task costs 5 credits. Enabling any of rawResponse, searchQueries, ads or shopping adds 2 once, however many you turn on, and synchronous calls add 2. markdown and html are free. The free tier grants 500 credits a month with no card, plan prices are on /pricing, and failed requests are not charged (credits).

Commerce blocks, citation pills and fan-out come in one response, with the same request and response conventions across ChatGPT, Perplexity, Gemini, Copilot, Grok, AI Mode and Google Search. Async batches take up to 500 tasks with webhooks and idempotency keys. Credits are per request, so a very large one-off census costs more than the cheapest per-page queues above.

Fits teams building AI-visibility, GEO or commerce products that need the parsed answer across several assistants.

OpenAI’s API with web search

OpenAI’s web search tool (web_search in the Responses API) returns url_citation annotations with the URL, title and location of each cited source, a sources list of every URL retrieved, and the search actions with their queries, and it accepts a user_location with country, city, region and timezone. Pricing is $10 per 1,000 calls plus search content tokens at model rates.

It is the right tool for generating answers inside your own application and the wrong one for measuring what ChatGPT tells people:

1. You pick the model, instructions and tool settings, so the output describes your configuration, not the app a buyer uses.
2. The guide does not describe shopping cards, product carousels or ads, where commerce visibility is decided in the app.
3. Citation presentation (which sources are grouped in which inline chip, in what order) is an interface decision the API does not replicate.

The provider APIs comparison goes through the differences field by field.

Building it yourself

A home-grown collector means sessions, per-market network egress, a queue, a parser for the answer, retries, and monitoring for the day the interface changes. The build vs buy breakdown itemizes the cost. Build only if collection is your product, or if you need something no vendor offers, such as logged-in personas with memory.

How to choose

1. Do you need the consumer answer? For visibility measurement, yes, which rules out model APIs.
2. Which fields will you compute on? Citation share needs ordered sources, retrieval analysis needs fan-out, commerce needs parsed products. Check each vendor’s schema for the exact field.
3. How many engines? If Perplexity, Gemini, Copilot and Google AI surfaces are on your roadmap, one contract across them saves a mapping layer per engine.
4. What latency can you accept? Queues are cheapest. Daily monitoring rarely needs live calls; agents and interactive tools do.
5. How do you target markets? Country is common; city, state or coordinates are not.
6. What happens on failure? Look for success-only billing, idempotency and webhooks. A daily job that double-runs or drops tasks corrupts trend lines.
7. Price at your volume with your flags: prompt count × markets × frequency, including add-ons.

Cost example

200 prompts, one market, collected daily for 30 days, with citations and fan-out: 6,000 ChatGPT answers a month. List prices checked 2026-09-17, before taxes, volume discounts and coupons:

The cheapest line is not necessarily the cheapest system once you add the engineering time to normalize each vendor’s schema, the cost of a missed day when a queue backs up, and a possible second vendor for the next engine. Budgeting across engines and cadences is covered in AI monitoring cost planning.

Daily ChatGPT collection on AnswerLine

For a daily prompt set, submit async tasks in batches and receive results on a webhook:

import os, datetime, requests

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

prompts = ["best CRM for agencies", "HubSpot vs Pipedrive for small teams"]
tasks = [
    {
        "taskType": "CHATGPT",
        "payload": {"prompt": p, "country": "US", "include": {"searchQueries": True}},
        "idempotencyKey": f"crm-{i}-US-{today}",
        "webhook": {"url": "https://example.com/hooks/answers"},
    }
    for i, p in enumerate(prompts)
]

r = requests.post(f"{API}/v1/async/task/batch", json=tasks, headers=HEADERS, timeout=30)
r.raise_for_status()
for item in r.json()["results"]:
    if not item["success"]:
        print(item["index"], item["error"]["code"])

Each finished task is POSTed to the webhook; for a COMPLETED task the ChatGPT result is at response.result. Idempotency keys derived from prompt, market and day make a retried submission safe. Verify the webhook signature before trusting the body.

Pitfalls that skew ChatGPT data

• Web search off by default. Some APIs only search when asked. An answer without search has no citations, and a mixed dataset makes citation share meaningless.
• One run per prompt. ChatGPT answers vary run to run, so track rates over repeated runs; see AI answer volatility.
• Treating markdown links as citations. Links pulled from text lose display order and grouping. Use the structured sources.
• Ignoring commerce blocks. In product categories the carousel can matter more than the prose; see ChatGPT shopping cards.
• Assuming every field is always filled. Optional fields such as fan-out can be empty for a given answer; store which fields were present with each result.

Field-by-field detail is on the ChatGPT engine page, and the quickstart covers a first request.

Keep reading