Quora Search Scraper: Answer Text & Upvote Ranking

Quora Search Scraper — Extract Answers, Questions and Profiles

Quora Search Scraper: Answer Text & Upvote Ranking searches Quora by keyword — or takes question, profile, topic and space URLs directly — and returns the full answer text, upvote counts, author details and question metadata as typed JSON. Unlike scraping frameworks that return raw HTML, it returns ready-to-use rows: deep per-question answer pagination, a minimum-upvote quality gate, upvote/recency ranking, and absolute answer dates alongside Quora's own relative age strings. No Quora account or login is required. This guide covers every input and output field and how teams run it as a keyword-monitoring, enrichment or bulk-dataset pipeline.

What does Quora Search Scraper do?

Quora Search Scraper turns a keyword or a Quora URL into structured rows covering five content types: questions, answers, profiles, topics and spaces. Enter search keywords and the Actor discovers relevant Quora question pages for you (via DuckDuckGo, with a Bing fallback); paste a direct URL and it classifies the page and extracts the matching entity. No Quora account, cookie or login is required — everything returned is data any anonymous visitor already sees.

• Discovers Quora question URLs from plain keywords, with no login and no cookies
• Mines full answer bodies (not truncated previews) via Quora's own embedded GraphQL data
• Pulls up to 100 answers per question through deterministic cursor pagination, not scroll-and-hope
• Applies a client-side minimum-upvote quality gate before ranking
• Orders answers by relevance, recency or upvotes, and stamps a 1-based answer_rank
• Scrapes direct profile, topic and space URLs into their own typed rows
• Optionally enriches each answer with an LLM-generated summary, sentiment and key points

Features & Capabilities

Quora Search Scraper covers keyword discovery, direct-URL scraping across five entity types, deterministic deep pagination, and optional AI enrichment — all billed per output row.

Core features

• Keyword search — one or more keywords each resolve to Quora question URLs, discovered without a Quora account
• Direct URL scraping — questions, profiles (/profile/...), topics (/topic/...) and spaces (/q/... or a subdomain) are auto-classified and routed to the matching parser
• Deterministic answer pagination — the variant's signature feature: instead of scrolling and hoping more answers render, it replays Quora's QuestionPagedListPaginationQuery persisted GraphQL query with a cursor, pulling exactly answersPerQuestion answers where available
• Upvote quality gate and ranking — minAnswerUpvotes drops weak answers before the sortAnswersBy order (relevance, recency, upvotes) assigns each surviving answer a 1-based answer_rank
• Absolute + relative freshness — every answer carries both answer_created_at (ISO-8601) and age_days (integer), alongside Quora's native relative string (answer_timestamp, e.g. "4y")
• AI-generated-answer detection — is_ai_answer flags Quora's own AI-authored answers, read from Quora's isMachineAnswer field — unrelated to this Actor's optional AI enrichment
• Optional AI enrichment — ai_summary, ai_sentiment and ai_key_points per answer, across 26 selectable models from 7 providers, off by default and always degrading to null on any failure

How the scrape actually runs

Quora sits behind Cloudflare, so a plain HTTP client gets an interstitial challenge instead of a page. The Actor renders every page with a stealth-patched Chromium browser (playwright-stealth) instead, and reads the data Quora already embeds in its own page payload — window.ansFrontendGlobals.data.inlineQueryResults on first load, plus the streamed gql_para_POST GraphQL responses captured while the page is open. Deep answer pagination replays Quora's own persisted QuestionPagedListPaginationQuery against that same browser session, so the Cloudflare clearance cookie and formkey stay valid across every page of the cursor. This is why the Actor can pull up to 100 answers on a single question without a slow scroll-and-wait loop: it asks Quora's own API for the next page directly, the same way Quora's own front end does.

How Quora Search Scraper compares to other Quora scrapers

Feature	Quora Search Scraper	memo23/Quora-Scraper-with-optional-login	crawlerbros/quora-search-scraper
Login / cookies required	No	Yes — cookies required for search access	No
Answer pagination method	Deterministic cursor (QuestionPagedListPaginationQuery)	Not documented	Scroll-based
Upvote quality gate on answers	Yes (minAnswerUpvotes)	Not documented	Not documented
Answer ranking (relevance/recency/upvotes)	Yes, with answer_rank	Not documented	Not documented
Absolute answer date + age in days	Yes (answer_created_at, age_days)	Not documented	Relative timestamp only
Optional AI summary/sentiment enrichment	Yes, 7 providers	Not documented	Not documented
Pricing model	Pay-per-event	Flat monthly price	Pay-per-event
Entity coverage	Questions, answers, profiles, topics, spaces	Questions and answers	Questions, answers, profiles, topics, spaces

Observed on the Apify Store on 25 July 2026, from each listing's own README. If your use case is feeding structured data to an LLM, the output-format row is the decision-maker — every field here is already typed JSON, so there is no HTML parsing step inside your agent loop to fail.

When another tool might suit you better

If you specifically need Quora content that is only visible while logged in — restricted spaces, or a Quora+ paywalled answer — memo23/Quora-Scraper-with-optional-login accepts session cookies and can reach further behind that wall than a login-free scraper ever will. This Actor deliberately stays login-free, so anything gated behind a Quora account is out of scope here.

Quora Search Scraper within the Scrapio data stack

Quora Search Scraper covers questions, answers, profiles, topics and spaces on Quora. For the same kind of thread-and-comment mining on Reddit, use Reddit Posts Scraper — Comment & Thread Analysis; for Reddit account-level auditing, use Reddit User Profile Scraper — Bot & Fake Account Detection. Both live in the Scrapio catalogue and share this Actor's typed-JSON, pay-per-event output shape.

Why do developers and data teams scrape Quora?

Quora's answers are long-form, opinionated, first-person text written by people staking a name and stated credentials to a claim — a different signal from a tweet or a star rating, and one that four groups draw on differently.

🏢 Content and SEO teams

Content teams run searchQueries against topics they plan to write about, then read the top-ranked answers (sortAnswersBy: "upvotes") to see which angles the audience already rewarded with upvotes. answer_text, author_credentials and question_title feed directly into a content brief — real phrasing and real objections, not a keyword list. Because answer_rank and upvotes are returned per row, a content tool can surface only the top 3–5 answers per question rather than every reply.

📊 AI training data and RAG indexing

answer_text is long-form, opinion-bearing natural language attributed to a named author with stated credentials (author_credentials) — exactly the shape RAG pipelines index for question-answering retrieval, and exactly the shape training pipelines use for instruction-response pairs. For RAG: chunk answer_text with question_title as the retrieval anchor and upvotes as a relevance prior. For training data: answer_rank, upvotes and answer_word_count give a consistent, numeric quality signal across every record without a separate scoring pass.

📱 Competitive and market intelligence

Teams track answer_count and follow_count per question over repeated runs to see which topics in their category are gaining attention on Quora, and re-run the same directUrls on a schedule to catch new answers and upvote shifts on questions that mention a competitor or product category by name.

🔬 Research and academic use

Public-opinion and social-science research draws on Quora's author_credentials field — a self-reported profession or affiliation attached to an opinion — for studies on stated-expertise framing, and on upvotes as a public-approval signal. Scope is limited to what Quora already shows an anonymous visitor; nothing behind a login is collected.

🍚 Input Parameters

All fields come directly from the Actor's input schema (.actor/actor.json). Nothing is required — supply at least one of searchQueries or directUrls or the run does nothing.

Parameter	Required	Type	Description	Example Value
searchQueries	No	array of string	Keywords to search on Quora. Each keyword discovers relevant Quora question URLs (via DuckDuckGo) and scrapes their answers. No Quora login needed.	["what is python used for"]
directUrls	No	array of string	Paste Quora URLs directly — questions, profiles, topics or spaces. Question URLs get the full answer-mining treatment. Supports bulk input (one per line).	["https://www.quora.com/What-is-Python-used-for"]
maxResults	No	integer, min 1, max 50000, default 10	Total number of result rows to collect — across all keywords and URLs combined (questions + answers).	100
includeAnswers	No	boolean, default true	When on, each question is expanded into its answers (full text + metrics). Turn off to collect question metadata only.	true
answersPerQuestion	No	integer, min 1, max 100, default 3	How many answers to pull per question via deterministic cursor pagination (not scroll-and-hope).	25
sortAnswersBy	No	string enum: relevance, recency, upvotes; default relevance	Order answers within each question before ranking. Client-side sort of the collected answers (not a Quora server-side sort).	"upvotes"
minAnswerUpvotes	No	integer, min 0, default 0	Drop answers with fewer upvotes than this.	10
aiEnhancement	No	boolean, default false	Analyse each answer body with an LLM (summary + sentiment + key points). Requires an API key below or a provider env var.	false
aiModel	No	string enum, 26 values, default claude-haiku-4-5	Model/provider for AI enrichment. Provider is auto-detected from the name prefix (claude-*=Anthropic, gpt-*/o1/o3=OpenAI, gemini-*=Google, grok-*=xAI, deepseek-*=DeepSeek, sonar*=Perplexity, mistral-*=Mistral).	"claude-haiku-4-5"
aiApiKey	No	string (secret — masked in the Apify Console, never logged)	API key for the chosen provider. If empty, the matching env var is used (ANTHROPIC_API_KEY / OPENAI_API_KEY / GEMINI_API_KEY / XAI_API_KEY / DEEPSEEK_API_KEY / PERPLEXITY_API_KEY / MISTRAL_API_KEY). Only used when AI Enrichment is on.	"sk-ant-..."
proxyConfiguration	No	object, editor proxy, default {"useApifyProxy": true}	Apify Proxy configuration used as the mid-tier (datacenter) network. Residential is applied automatically as the final fallback.	{"useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"]}

The full enum for aiModel spans Claude Haiku 4.5 / Sonnet 5 / Opus 4.8 / Fable 5 (Anthropic), GPT-4o mini / GPT-4o / GPT-4.1 mini / GPT-4.1 / o3-mini / o1 (OpenAI), Gemini 2.0 Flash-Lite / 2.0 Flash / 1.5 Pro / 2.5 Flash / 2.5 Pro (Google), Grok 2 / 3 mini / 3 / Beta (xAI), DeepSeek Chat / Reasoner, Sonar / Sonar Pro / Sonar Reasoning (Perplexity), and Mistral Small / Large.

Example input

{
  "searchQueries": ["what is python used for"],
  "directUrls": ["https://www.quora.com/topic/Python-programming-language-1"],
  "maxResults": 100,
  "includeAnswers": true,
  "answersPerQuestion": 25,
  "sortAnswersBy": "upvotes",
  "minAnswerUpvotes": 10,
  "aiEnhancement": false,
  "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"] }
}

Supported URL types and input formats

• Questions — https://www.quora.com/What-is-Python-used-for — get full answer mining
• Profiles — https://www.quora.com/profile/Guido-van-Rossum-1 — path contains /profile/
• Topics — https://www.quora.com/topic/Python-programming-language-1 — path contains /topic/
• Spaces — https://www.quora.com/q/data-science or a space subdomain — path starts with /q/

searchQueries and directUrls both accept a plain list or a newline/comma-separated string. Direct URLs are validated (http/https scheme with a host) before being scraped — malformed entries are silently dropped rather than attempted. For compatibility with tools that emit a generic bulk-URL field, the Actor also reads a top-level urls array and merges it with directUrls, though directUrls is the documented field. A URL that does not match the profile, topic or space patterns is always routed to the question scraper.

📦 Output Format

Every run pushes typed, normalized JSON rows to the default dataset, one row per question, answer, profile, topic or space. Every row carries a content_type key so you can filter by entity type, and the Output tab's view dropdown switches between six pre-built views (🗂️ All Results, 💬 Ranked Answers, ❓ Questions, 👤 Profiles, 🏷️ Topics, 🪘 Spaces) — each view is a column subset of the full row, not a different dataset. Export as JSON, CSV or Excel, or read the dataset through the Apify API.

Output for answers

The richest row shape, with 25 keys. ai_summary, ai_sentiment and ai_key_points are present on every answer row and are null unless aiEnhancement is on and the enrichment call succeeds.

{
  "content_type": "answer",
  "title": "What is Python primarily used for?",
  "url": "https://www.quora.com/What-is-Python-primarily-used-for/answer/Bill-Poucher",
  "answer_text": "Python is a general-purpose programming language used for web development, data analysis, automation, and scientific computing...",
  "answer_url": "https://www.quora.com/What-is-Python-primarily-used-for/answer/Bill-Poucher",
  "author_name": "Bill Poucher",
  "author_url": "https://www.quora.com/profile/Bill-Poucher",
  "author_credentials": "ICPC Executive Director",
  "upvotes": 15,
  "comments_count": 2,
  "shares_count": 4,
  "answer_timestamp": "9y",
  "answer_rank": 1,
  "answer_created_at": "2017-04-12T09:31:00+00:00",
  "age_days": 3381,
  "answer_word_count": 128,
  "is_ai_answer": false,
  "question_title": "What is Python primarily used for?",
  "question_url": "https://www.quora.com/What-is-Python-primarily-used-for",
  "source_url": "https://www.quora.com/What-is-Python-primarily-used-for",
  "source_query": "what is python used for",
  "scrape_timestamp": "2026-07-25T07:40:52.140078+00:00",
  "ai_summary": null,
  "ai_sentiment": null,
  "ai_key_points": null
}

Output for questions

{
  "content_type": "question",
  "title": "What is Python primarily used for?",
  "url": "https://www.quora.com/What-is-Python-primarily-used-for",
  "answer_count": 100,
  "follow_count": 42,
  "topics": ["Python (programming language)", "Software Development"],
  "source_url": "https://www.quora.com/What-is-Python-primarily-used-for",
  "source_query": "what is python used for",
  "scrape_timestamp": "2026-07-25T07:40:52.140078+00:00"
}

Output for profiles, topics and spaces

Direct URLs to these three entity types return one row each, with fewer fields than a question or answer row since Quora exposes less structured data on these page types.

Entity	Keys returned
Profile	content_type, title, name, url, bio, credentials, profile_image_url, follower_count, following_count, answer_count, question_count, total_views, source_url, scrape_timestamp
Topic	content_type, title, name, url, description, follower_count, question_count, source_url, scrape_timestamp
Space	content_type, title, name, url, description, follower_count, post_count, contributor_count, source_url, scrape_timestamp

{
  "content_type": "profile",
  "title": "Guido van Rossum",
  "name": "Guido van Rossum",
  "url": "https://www.quora.com/profile/Guido-van-Rossum-1",
  "bio": "Creator of the Python programming language",
  "credentials": "Creator of Python",
  "profile_image_url": "https://qph.cf2.quoracdn.net/main-thumb.jpg",
  "follower_count": 3100,
  "following_count": 15,
  "answer_count": 42,
  "question_count": 5,
  "total_views": 1200000,
  "source_url": "https://www.quora.com/profile/Guido-van-Rossum-1",
  "scrape_timestamp": "2026-07-25T07:40:52.140078+00:00"
}

Schema stability and export options

Field names stay stable across runs regardless of Quora front-end changes — the Actor reads Quora's own embedded GraphQL payload rather than parsing rendered HTML, so a visual redesign does not by itself change a key name. A structural change to the payload itself is a maintenance event for the Actor, not something you need to detect on your end; your field names and types do not change.

Every row pushed to the dataset is billed through the row_result pay-per-event — there is no separate unbilled accounting or error row mixed into the dataset, and no filter is needed to strip out non-billed rows before analysis. Export from the Output tab as JSON, CSV or Excel, or pull the dataset programmatically through the Apify API or apify_client.

💡 Quora Search Scraper: Answer Text & Upvote Ranking Strategy Guide

🎯 Strategy 1: Real-time enrichment pipeline

Trigger a run per inbound record — a support ticket, a lead's stated interest, a content request — using that record's topic as a searchQueries entry with answersPerQuestion: 10 and sortAnswersBy: "upvotes". Read back answer_text, upvotes and author_credentials from the top-ranked answers and append them to the source record (a CRM field, a ticket note, a brief). Turn on aiEnhancement if you want ai_summary written straight into the same field instead of the raw answer text.

🎯 Strategy 2: Scheduled monitoring and alerting

Save the same directUrls (question or topic pages in your category) and schedule the run via an Apify Schedule — daily or weekly. Diff each new run's answer_count, upvotes and answer_rank per url against the previous run's dataset, and alert only when a tracked question gains a new top-ranked answer or a meaningful upvote jump. This catches new expert opinion on a topic without re-reading every question by hand.

🎯 Strategy 3: Bulk dataset build

List every keyword or question URL you need in searchQueries / directUrls for a single run, set maxResults to your total target row count, and let the run stream rows to the dataset as it works — no fixed concurrency limit is documented for this Actor beyond your Apify plan's own run concurrency. Export the finished dataset to CSV for a spreadsheet pipeline, or read it via the Apify API into a database for an internal Q&A search tool or a RAG corpus.

Strategy comparison at a glance

Strategy	Best for	Run pattern	Output format
Real-time enrichment	Enriching one inbound record at a time	On-demand single run per record	JSON appended to source system
Scheduled monitoring	Tracking answer/upvote changes over time	Apify Schedule, recurring	Dataset diffed run-over-run
Bulk dataset build	Research or training-data corpora	One large run, high maxResults	CSV / database via API

🌴 Related Quora Scrapers & Tools

Scraper Name	What it extracts
Reddit Posts Scraper — Comment & Thread Analysis	Reddit posts plus full nested comment threads, with per-post engagement rollups
Reddit User Profile Scraper — Bot & Fake Account Detection	Reddit account post history plus an authenticity/bot-risk score

Both are Scrapio Actors covering the same long-form-discussion use case on Reddit instead of Quora, for teams that need Q&A-style community data across more than one platform. Where this Actor ranks Quora answers by upvotes and applies a minimum-upvote gate, the Reddit posts Actor computes an equivalent per-post engagement rollup — top commenters, most-upvoted comment, average score — so the two can feed the same downstream scoring logic even though the source platforms differ.

How to integrate Quora Search Scraper with your stack

Quora Search Scraper works with any language or tool that can make an HTTP request, through the Apify API and apify_client SDKs.

Python

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run_input = {
    "searchQueries": ["what is python used for"],
    "answersPerQuestion": 25,
    "sortAnswersBy": "upvotes",
    "minAnswerUpvotes": 10,
    "maxResults": 100,
    "proxyConfiguration": {"useApifyProxy": True, "apifyProxyGroups": ["RESIDENTIAL"]},
}

run = client.actor("<YOUR_USERNAME>/quora-search-scraper-answer-text-upvote-ranking").call(run_input=run_input)

rows = []
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    if item.get("content_type") == "answer":
        rows.append(item)

import csv
with open("quora_answers.csv", "w", newline="", encoding="utf-8") as f:
    writer = csv.DictWriter(f, fieldnames=rows[0].keys())
    writer.writeheader()
    writer.writerows(rows)

print(f"Saved {len(rows)} answer rows to quora_answers.csv")

Node.js

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });

const run = await client.actor('<YOUR_USERNAME>/quora-search-scraper-answer-text-upvote-ranking').call({
    searchQueries: ['what is python used for'],
    answersPerQuestion: 25,
    sortAnswersBy: 'upvotes',
    maxResults: 100,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
const answers = items.filter((row) => row.content_type === 'answer');

console.log(`Collected ${answers.length} answer rows`);

Both scripts read content_type to separate answer rows from question, profile, topic and space rows in the same dataset — the field every row carries regardless of which entity it represents.

Async and scheduled pipelines

There is no webhook-delivery input on this Actor. For fire-and-forget large jobs, start the run through the API and poll the run status (or the dataset item count) until it finishes, or configure an Apify webhook on the run's ACTOR.RUN.SUCCEEDED event from the Apify Console to notify your own endpoint. Recurring extraction is handled by an Apify Schedule on this Actor's saved input.

Who needs Quora Search Scraper? (Use cases & industries)

🏢 Content and SEO teams

A content strategist enters a target keyword in searchQueries, sets sortAnswersBy: "upvotes", and reads the top answer_text values as source material for a brief — real audience-validated framing instead of a guess at what people want to know.

📊 AI engineers building RAG and training pipelines

An AI engineer indexes answer_text, question_title and upvotes into a vector store so an internal assistant can answer "what does Quora say about X" by retrieving the actual highest-upvoted answers, or exports the same fields as instruction-response pairs for fine-tuning.

📱 Market and competitive intelligence analysts

An analyst tracking a product category re-runs the same directUrls weekly and watches answer_count and upvotes per question for a spike that signals rising interest or a competitor mention gaining traction.

🔬 Researchers

A social-science researcher pulls author_credentials alongside answer_text and upvotes across a topic to study how self-reported expertise correlates with public approval — using only what Quora already shows an anonymous visitor.

Is it legal to scrape Quora?

Scraping publicly accessible web pages is broadly permissible in the United States; courts have held that accessing data that does not require a login does not violate the Computer Fraud and Abuse Act (hiQ Labs, Inc. v. LinkedIn Corp., 9th Cir., 2019). That precedent addresses unauthorized-access law, not Quora's own terms of service — violating a platform's ToS is a matter of contract and civil risk, not a criminal one, and enforcement varies by platform and use.

Quora answers carry personal data: an author's display name, self-reported credentials, bio and follower counts. This Actor collects only what Quora already displays to a logged-out visitor — nothing gated behind a login is accessed. If you plan to store or process this personal data at scale, GDPR, CCPA or an equivalent local law may apply to your use, independent of how the data was collected. None of that changes the underlying question-and-answer content itself, which is editorial text the author chose to publish to the public web.

Quora Search Scraper returns only publicly accessible data. What you do with that data is your responsibility — consult legal counsel for commercial applications involving personal data.

❓ Frequently asked questions

Does Quora Search Scraper work without a Quora account?

Yes. No login, cookie or session is used anywhere in the Actor — keyword search and direct-URL scraping both work against Quora's logged-out view.

How does Quora Search Scraper handle Quora's anti-scraping measures?

Quora sits behind Cloudflare, so pages are rendered with a stealth Chromium browser rather than a plain HTTP client. The Actor starts unproxied, and on a detected block (a Cloudflare interstitial, or a search/scrape attempt returning nothing) it escalates through a proxy ladder: unproxied, then a plain Apify Proxy tier, then a RESIDENTIAL-group Apify Proxy tier, sticking on residential once reached. Only the apifyProxyCountry sub-field of your proxyConfiguration input is read by this ladder (at the residential tier); the escalation logic itself always uses Apify Proxy and does not read your apifyProxyGroups selection directly.

Can I run Quora Search Scraper at scale without getting blocked?

The Actor retries failed page loads and question-URL discovery attempts, escalating its proxy tier on repeated failure, with extra retries once it reaches the residential tier. By default a blocked page gets up to 3 attempts on its current proxy tier, and once the ladder is stuck on the residential tier it grants up to 3 further retries there before giving up on that URL and moving on. No uptime or success-rate figure is published for this behavior — how much of a large run completes depends on Quora's blocking behavior at the time of the run.

How fresh is the data Quora Search Scraper returns?

Every row is a live fetch for that run — scrape_timestamp is set at collection time and there is no caching layer. Re-run the Actor to get current upvote counts and any new answers.

Which Quora fields work best for AI training and RAG indexing?

For RAG: answer_text as the retrievable content, with question_title as the anchor and upvotes as a relevance prior. For training data: answer_rank, upvotes and answer_word_count are the most structurally consistent numeric fields across every answer row. Every field returns as a typed primitive — no HTML or markdown to strip before indexing.

Does scraping Quora raise data protection concerns?

Author names, bios and credentials on Quora are personal data about real people, even though Quora displays them publicly. The Actor returns only what an anonymous visitor already sees — no private or login-gated field is collected — but the lawful basis for storing and using that personal data in your own system is yours to establish, not the Actor's.

Does Quora Search Scraper work with Claude, ChatGPT and other AI agent tools?

Yes, as a standard HTTP endpoint through the Apify API — any agent framework that can make a request (LangChain, CrewAI, a custom tool definition, n8n) can call it and receive typed JSON directly, with no parsing step before it enters an LLM context window.

What happens if my search keywords return no matching questions?

The run finishes with zero rows rather than a fabricated or partial result. Internally, keyword discovery tries DuckDuckGo's interactive results, then DuckDuckGo's static HTML endpoint, then Bing, and if a whole round comes up empty it escalates the proxy tier and retries — with three extra attempts once it reaches the residential tier — before giving up on that keyword. If every keyword and direct URL in the run ends this way, the log explicitly suggests enabling the Apify RESIDENTIAL proxy group, since a fully blocked network is the most common cause.

Can I collect only question metadata without pulling every answer?

Yes. Set includeAnswers to false and each discovered or supplied question returns a single question-level row — title, url, answer_count, follow_count, topics — with no answer scraping, no pagination, and a faster, cheaper run. This is the setting to use when you only need to know how many answers a question has, not their content.

How does Quora Search Scraper compare to other Quora scrapers?

Checked on the Apify Store on 25 July 2026: memo23/Quora-Scraper-with-optional-login requires Quora account cookies for search access and charges a flat monthly price, which suits use cases needing content behind a login wall but adds an authentication step this Actor avoids. crawlerbros/quora-search-scraper covers the same five entity types without a login and on pay-per-event pricing, but its own README does not document deterministic answer pagination, an upvote quality gate, answer ranking, or AI enrichment — the four features this variant adds on top of that shared base. Neither competitor's listing documents an absolute answer date field; both describe only Quora's native relative timestamp string.

Disclaimer

Quora Search Scraper extracts only publicly available data from Quora. This tool is intended for lawful use cases only. Users are responsible for complying with Quora's terms of service and applicable data protection laws in their jurisdiction.