# Quora Search Scraper — Questions, Answers, Views & Authors (`scrapersdelight/quora-search-scraper`) Actor

Find Quora questions by keyword, topic or URL and get each one with its answers nested: author, credential, full text, upvotes, views, shares, date, plus the question's exact view count, creation date, followers and topics. Logged-out, no cookies. $0.0007/question, $0.0006/answer.

- **URL**: https://apify.com/scrapersdelight/quora-search-scraper.md
- **Developed by:** [Scrapers Delight](https://apify.com/scrapersdelight) (community)
- **Categories:** Social media, AI, Marketing
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.70 / 1,000 per question delivereds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Quora Search Scraper — Questions, Answers, Views & Authors

Find [Quora](https://www.quora.com) questions by **keyword**, **topic** or **URL** and get one clean
row per question — **title, URL, qid, answer count, follower count, comment count, exact view count,
creation date, merge count, topics** and Quora's own **related questions** — with the question's
**answers nested inside the row**: author name, profile URL and credential line, full text (plain
**and** Markdown), upvotes, views, shares, comments, answer date, links and images, plus flags for
AI-generated, paywalled-preview, collapsed and anonymous answers.

Every number is an **exact integer from Quora's own API** — `numViews: 17851`, not the display string
"17.8K" — so nothing is rounded and nothing is approximated. No Quora account needed — and if you
have one, you can optionally paste your own Quora cookie to use Quora's own search for keywords.

```json
{
  "queries": ["web scraping"],
  "maxQuestions": 50,
  "maxAnswersPerQuestion": 10
}
```

Click **Try for free** and hit **Start** — that block is the input the Actor ships with. On the
Apify platform (build 0.1.12, 2026-09-23, run `oq8X2ZunnrpCa9ccQ`) it returned **50 questions and
172 answers in 52 seconds**, 50 distinct question ids, **charged exactly 50 + 172**, with the
question's view count and creation date on **50/50** rows and the answer author on **171/172**
answers (the 172nd is an anonymous answer, which Quora publishes without a name).

***

### The wedge: what the other Quora scrapers on the Store don't give you

- **Answers nested in the question row, billed per answer.** One record type, so your spreadsheet
  never mixes question rows with answer rows. Every other Quora actor on the Store bills an answer
  as a whole record: a question with 10 answers costs **$0.0067 here** vs $0.0088 at the cheapest
  working rival and $0.0109 at the most-used one.
- **Direct answers kept apart from what Quora mixes in.** Quora's answer list is not a list of
  answers to your question — it interleaves answers written to *other* questions. Every answer
  carries `relation`: `direct` (written to this question), `equivalent-question` (Quora's
  "same question, different wording"), `related-question`, or `ai` (Quora's own AI answer). The
  default keeps **direct answers only** — measured on "What is web scraping?": Quora's list held 105
  items, of which **42 were direct, exactly Quora's `answerCount` of 42**.
- **Question view count and creation date — exact.** Not on Quora's logged-out question page at all;
  this Actor reads them with the query Quora's own question-log page uses. **100% filled on every
  measured frame — 50/50, 200/200 and 150/150.** Also: `mergedQuestionCount` (how many duplicate
  questions Quora folded into this one) and `lastFollowedAt`.
- **Honest truncation.** When Quora's logged-out list stops before the answers it counts, the row
  says so — `answersTruncated: true` plus a plain-English `answersNote` — instead of shipping a short
  list that looks complete. A paywalled Quora Spaces answer is served to logged-out visitors as a
  cut-off preview; it ships with `textIsPreview: true`, never as a whole answer.
- **Markdown + links + images per answer.** `textMarkdown` keeps bold, italics, lists, links, code
  blocks and embedded images; `links[]` and `images[]` list them separately; `wordCount` and
  `textLength` let you rank by effort.

***

### Read this before you buy rows

1. **Keyword search runs through the open web, not quora.com/search.** Quora's own search is
   login-only: logged out, `quora.com/search?q=` redirects to the home page and Quora's search API
   answers `searchConnection: null` (measured 2026-09-23 on www, es and de). So a keyword is searched
   as `site:quora.com <keyword>` on Brave (then DuckDuckGo, then Bing) and then widened through
   Quora's own related-question links — keeping only related questions whose title contains every
   word of your keyword. You get the questions the web ranks for your keyword, not Quora's in-app
   ranking. Brave returns about **38–75 question links per keyword** across its result pages
   (measured on 8 keywords); the related-question graph carries a keyword past that. To use Quora's
   own search ranking instead, paste your own logged-in Quora cookie into `quoraCookie` (see
   "How to run it", 6).
2. **Quora's logged-out list does not always serve every answer it counts.** On the shipped default
   run **9 of 50 questions** (44 of 200 and 26 of 150 on the two keyword frames) had fewer direct answers served than
   Quora's `answerCount` — e.g. "How can I lose weight fast?" counts 16 and serves 2. Quora's own
   collapsed-answers endpoint reports **0 collapsed answers** for it, so the rest are simply not
   shown to logged-out visitors. Those rows are flagged, never padded.
3. **Unanswered questions are delivered, with `answerCount: 0`.** Quora moves them to
   `/unanswered/<slug>` and this Actor follows it. Set `minAnswerCount: 1` to skip them (not billed).
4. **Counts are a live snapshot.** Views, upvotes and follower counts are read at scrape time.
5. **Anonymous answers** ship with `authorName: null` and `authorProfileUrl: null`.

***

### What you get

One row per unique question, de-duplicated run-wide on Quora's `qid`. Timestamps are UTC ISO-8601.

| Group | Fields | Example (real, run `oq8X2ZunnrpCa9ccQ`) |
|---|---|---|
| **Identity** | `qid`, `url`, `slug`, `title`, `language` | `200914012` · `How can I efficiently scrape data from websites…?` · `en` |
| **Engagement** | `answerCount`, `followerCount`, `viewCount`, `commentCount` | `2` · `1` · `1168` · `0` |
| **Time** | `createdAt`, `lastFollowedAt` | `2024-10-15T18:07:42.267Z` |
| **Structure** | `topics[]`, `topicUrls[]`, `mergedQuestionCount`, `isLocked`, `askerUid` | `Web Scraping`, `Web Crawling`, … · `0` · `false` |
| **Related** | `relatedQuestions[]` — `qid`, `url`, `title`, `answerCount`, `viewCount`, `createdAt` | `What are the best non-coding web scraping tools?` · 3,892 views |
| **Provenance** | `source` (`search` / `url` / `topic` / `related`), `sourceQuery`, `sourceEngine`, `searchRank`, `scrapedAt` | `search` · `web scraping` · `brave` · `3` |
| **Answer summary** | `answersIncluded`, `answersReturned`, `answersDirectSeen`, `answersEquivalentSeen`, `answersRelatedSeen`, `answersAiSeen`, `answerListExhausted`, `answersTruncated`, `answersNote`, `statsAvailable` | `2` · `2` · `false` |
| **Answers** | `answers[]` — see below | |

Each entry in `answers[]`:

| Group | Fields |
|---|---|
| **Identity** | `answerId`, `url`, `listPosition`, `relation`, `isDirectAnswer`, `isAiGenerated`, `answeredQuestionUrl`, `answeredQuestionTitle` (non-direct answers only) |
| **Author** | `authorName`, `authorProfileUrl`, `authorCredential`, `authorIsVerified`, `authorAnswerCount`, `authorTotalViews`, `isAnonymous` |
| **Content** | `text`, `textMarkdown`, `textLength`, `wordCount`, `links[]`, `images[]` |
| **Engagement** | `upvotes`, `views`, `shares`, `comments` |
| **Time** | `createdAt`, `updatedAt` |
| **Flags** | `isCollapsed`, `isDeleted`, `moderationCollapseType`, `isPaywalled`, `viewerHasAccess`, `textIsPreview` |

The dataset ships with two saved views: **Quora questions** (one line per question) and **Answers**
(one line per answer, unwound from `answers[]`, ready for a CSV).

***

### Field fill — measured, three sampling frames

Frame 1 = the shipped default (`{}`, keyword "web scraping", run `oq8X2ZunnrpCa9ccQ`, 50 questions,
172 answers). Frame 2 = "home insurance", "electric cars", "remote work tips", "best laptop for
students" (run `O6RJeQleSc0gbIouT`, 200 questions, 687 answers). Frame 3 = "credit card rewards",
"learn guitar", "moving to canada", "small business marketing" (run `OyNrYgxGFh6fO0xRG`, 150
questions, 680 answers). Quote a range, not a single number.

**Question rows**

| Field | Frame 1 | Frame 2 | Frame 3 | Note |
|---|---|---|---|---|
| qid, url, title, slug, answerCount, followerCount, topics, relatedQuestions, source | **100%** | **100%** | **100%** | |
| viewCount, createdAt, mergedQuestionCount | **100%** | **100%** | **100%** | |
| commentCount, isLocked | 90% | 93% | 95% | Quora omits them on some questions — null, never 0 |
| lastFollowedAt | 94% | 80% | 74% | null when nobody ever followed the question |
| answersNote | 18% | 22% | 17% | present exactly when the answer list is truncated |

**Answers** (default scope `direct`)

| Field | Frame 1 | Frame 2 | Frame 3 | Note |
|---|---|---|---|---|
| answerId, url, upvotes, views, shares, comments, createdAt | **100%** | **100%** | **100%** | |
| text, textMarkdown | **100%** | 99.9% | **100%** | one image-only answer carries no text |
| authorName, authorProfileUrl | 99.4% | **100%** | 99.0% | the rest are anonymous answers (`isAnonymous: true`) |
| authorCredential | 83% | 88% | 86% | null when the author never wrote a credential line |
| authorAnswerCount, authorTotalViews | 41% | 76% | 70% | Quora shows the author fact box on some answers only |
| links | 40% | 12% | 10% | answers that cite a link |
| images | 12% | 10% | 7% | answers with an embedded image |
| updatedAt | 16% | 13% | 14% | only answers edited after posting |
| isPaywalled true / textIsPreview true | 2.3% / 1.7% | 8.0% / 3.3% | 7.9% / 4.0% | Quora Spaces paywall |
| answeredQuestionTitle | 0% | 0% | 0% | **by design** — only set on non-direct answers; 91/91 filled on an `answerScope: "all"` run (`T4dfP5HYLUdaGf2Bd`) |
| isAiGenerated true | 0% | 0% | 0% | off by default; 4 of 120 answers on the `includeAiAnswers: true` run |

***

### How to run it

#### 1. Keyword research (the usual choice)

```json
{
  "queries": ["best crm for small business", "crm for startups"],
  "maxQuestions": 100,
  "maxAnswersPerQuestion": 10,
  "strictSearch": true
}
```

#### 2. Specific questions — full answer lists

```json
{
  "queries": [],
  "questionUrls": ["https://www.quora.com/What-is-web-scraping"],
  "maxAnswersPerQuestion": 100
}
```

Measured: "What is web scraping?" → 42 direct answers of Quora's 42.

#### 3. A topic's questions

```json
{
  "queries": [],
  "topics": ["Web Scraping"],
  "maxQuestionsPerQuery": 30
}
```

Quora serves about 30 feed items per topic to logged-out visitors (measured: the feed ends after
3 pages even in a real browser); related questions widen it from there.

#### 4. Brand / GEO monitor — recent questions only, questions without answers skipped

```json
{
  "queries": ["notion vs obsidian"],
  "dateFrom": "2025-01-01",
  "minAnswerCount": 1,
  "answerScope": "equivalent"
}
```

#### 5. Question rows only (cheapest)

```json
{ "queries": ["home insurance"], "includeAnswers": false, "maxQuestions": 200 }
```

#### 6. Quora's own search, with your own cookie

```json
{
  "queries": ["best crm for small business"],
  "quoraCookie": "<paste the whole cookie header from your logged-in quora.com session>",
  "maxQuestions": 50
}
```

Open quora.com while logged in, open DevTools → Network, click any request to quora.com and copy the
whole `cookie` request header (it contains `m-b`, `m-lat` and similar values). The field is stored as
a secret. With it, each keyword is searched with Quora's own search (rows get
`sourceEngine: "quora-native"`); question rows and answers are still read the logged-out way, so the
row format is identical. If the cookie has expired or is not accepted, the run does not fail: it
falls back to web-search discovery and `RUN_SUMMARY.nativeSearch` says why. Billing is the same.

Schedule any of these in Apify (daily / weekly) and send the dataset to Google Sheets, Slack, Make,
Zapier or a webhook with Apify's integrations.

***

### Sample row

A real row from the shipped-default run (`oq8X2ZunnrpCa9ccQ`, 2026-09-23). `topics` and
`relatedQuestions` are cut to a few entries here; the row had 15 topics and 10 related questions.

```json
{
  "qid": 200914012,
  "url": "https://www.quora.com/How-can-I-efficiently-scrape-data-from-websites-using-web-scraping-and-web-crawling-tools-1",
  "title": "How can I efficiently scrape data from websites using web scraping and web crawling tools?",
  "slug": "How-can-I-efficiently-scrape-data-from-websites-using-web-scraping-and-web-crawling-tools-1",
  "askerUid": 141307929,
  "answerCount": 2,
  "followerCount": 1,
  "viewCount": 1168,
  "commentCount": 0,
  "createdAt": "2024-10-15T18:07:42.267Z",
  "lastFollowedAt": "2024-10-15T18:07:42.307Z",
  "mergedQuestionCount": 0,
  "isLocked": false,
  "language": "en",
  "topics": ["Data Collection", "Web Analytics", "Web Scraping", "Web Crawling"],
  "topicUrls": ["https://www.quora.com/topic/Data-Collection", "https://www.quora.com/topic/Web-Analytics", "https://www.quora.com/topic/Web-Scraping", "https://www.quora.com/topic/Web-Crawling"],
  "source": "search",
  "sourceQuery": "web scraping",
  "sourceEngine": "brave",
  "searchRank": 3,
  "relatedQuestions": [
    { "qid": 124468593, "url": "https://www.quora.com/What-are-the-best-non-coding-web-scraping-tools", "title": "What are the best non-coding web scraping tools?", "answerCount": 2, "viewCount": 3892, "createdAt": "2022-08-02T07:21:22.793Z" }
  ],
  "answersIncluded": true,
  "answers": [
    {
      "answerId": "1477743820340759",
      "url": "https://www.quora.com/How-can-I-efficiently-scrape-data-from-websites-using-web-scraping-and-web-crawling-tools-1/answer/SoLostOMG",
      "listPosition": 0,
      "relation": "direct",
      "isDirectAnswer": true,
      "isAiGenerated": false,
      "answeredQuestionUrl": "https://www.quora.com/How-can-I-efficiently-scrape-data-from-websites-using-web-scraping-and-web-crawling-tools-1",
      "answeredQuestionTitle": null,
      "authorName": "SoLostOMG",
      "authorProfileUrl": "https://www.quora.com/profile/SoLostOMG",
      "authorCredential": "I know a few things about web scraping",
      "authorIsVerified": false,
      "authorAnswerCount": null,
      "authorTotalViews": null,
      "isAnonymous": false,
      "text": "For starter, you may want to take a look at Scrapy, along with BeautifulSoup. There are other options but this is what I use. Then once you get a hang of scraping a simple HTML website, Scrapy Playwright should be the next tool for dynamic websites. Also a little python knowledge is compulsory",
      "textMarkdown": "For starter, you may want to take a look at Scrapy, along with BeautifulSoup. There are other options but this is what I use. Then once you get a hang of scraping a simple HTML website, Scrapy Playwright should be the next tool for dynamic websites. Also a little python knowledge is compulsory\n\n[Scrapy 2.19 documentation](https://doc.scrapy.org/)",
      "textLength": 294,
      "wordCount": 53,
      "links": ["https://doc.scrapy.org/"],
      "images": [],
      "upvotes": 0,
      "views": 401,
      "shares": 0,
      "comments": 0,
      "createdAt": "2024-10-16T02:42:40.013Z",
      "updatedAt": null,
      "isCollapsed": false,
      "isDeleted": false,
      "moderationCollapseType": null,
      "isPaywalled": false,
      "viewerHasAccess": true,
      "textIsPreview": false
    }
  ],
  "answersReturned": 2,
  "answersDirectSeen": 2,
  "answersEquivalentSeen": 0,
  "answersRelatedSeen": 0,
  "answersAiSeen": 0,
  "answerListExhausted": false,
  "answersTruncated": false,
  "answersNote": null,
  "statsAvailable": true,
  "scrapedAt": "2026-09-23T06:05:51.207Z"
}
```

(The row's second answer, by "Future Read AI Solution", is omitted above for length.)

***

### Input

| Field | Default | What it does |
|---|---|---|
| `queries` | `["web scraping"]` | Keyword phrases, one per line. Searched as `site:quora.com` on the web, then widened through related questions. |
| `questionUrls` | `[]` | Question URLs (also answer permalinks, `?share=1`, `/unanswered/`, language editions). Merged questions follow the merge. |
| `topics` | `[]` | Topic names or `/topic/` URLs. |
| `quoraCookie` | — | Optional, secret. Your own logged-in Quora cookie header; keywords then use Quora's own search. |
| `maxQuestions` | `50` | Total unique questions. Your hard cap on the question charge. `0` = no limit. |
| `maxQuestionsPerQuery` | `50` | Per keyword / topic cap. Pasted URLs are never capped by it. |
| `includeAnswers` | `true` | Nest answers into `answers[]`. |
| `maxAnswersPerQuestion` | `10` | Answers per question (1–1000), Quora's own ranking order. |
| `answerScope` | `direct` | `direct` · `equivalent` (+ equivalent-question answers) · `all` (everything Quora shows). |
| `includeAiAnswers` | `false` | Include Quora's AI-written answer, flagged `isAiGenerated`. |
| `expandRelated` | `true` | Widen through Quora's related questions (title must contain every keyword word). |
| `strictSearch` | `false` | Keep only questions whose title contains every keyword word. |
| `minAnswerCount` | `0` | Skip questions with fewer answers (not billed). |
| `dateFrom` / `dateTo` | — | Question creation window, `YYYY-MM-DD` UTC (not billed when outside). |
| `includeQuestionStats` | `true` | View count, creation date, merges, last follow (one extra request per question). |
| `maxRelatedQuestions` | `10` | Related questions listed per row (0–50, free). |
| `residentialFallback` | `true` | Use Apify RESIDENTIAL only when direct requests stay challenged. |
| `proxyConfiguration` | direct | Route everything through your own proxy instead. |
| `concurrency` | `4` | Questions read in parallel (1–8). |

***

### Pricing

Pay per event — you pay only for what is delivered:

| Event | Price | When |
|---|---|---|
| `question-scraped` | **$0.0007** | once per unique question delivered |
| `answer-scraped` | **$0.0006** | once per answer nested in a delivered question |

No start fee. Filtered-out questions, URLs that are not live questions and questions Quora would not
serve after retries cost nothing, and a question found by two keywords is billed once.

- The shipped default (50 questions, ≤10 answers each) costs **at most $0.335**; the measured run
  cost **$0.1382** (50 × $0.0007 + 172 × $0.0006).
- 1,000 questions without answers: **$0.70**. 1,000 questions with ~3.5 answers each (the measured
  average at a 10-answer cap): about **$2.80**.

For comparison (Store, 2026-09-23): the cheapest working Quora actor that bills questions charges
$0.0008 per record plus $0.005 per run and bills every answer as a full record; the cheapest
answer-only actor charges $0.00069 per answer plus $0.002 per run and has no keyword search.

***

### Limits

- **Keyword discovery is web-search based** unless you supply `quoraCookie` (see "Read this before
  you buy"). If Brave refuses
  the run's IP, the Actor retries it on a residential IP, then tries DuckDuckGo and Bing — which in
  our measurements return 0–1 Quora links per keyword from Apify's network. A keyword whose
  results the engines refuse outright yields its questions only from any other keyword's related
  graph.
- **Logged-out answer lists can be short** — 18–21% of questions in our two frames. Flagged per row.
- **Topic feeds are shallow logged-out** (~30 items per topic). Related questions widen them.
- **Quora sits behind Cloudflare.** The Actor passes it with a real browser TLS fingerprint and
  retries challenges on fresh connections; on a busy or burnt Apify IP it falls back to Apify
  RESIDENTIAL. A question that is still refused after 8 attempts is reported in `RUN_SUMMARY` as
  unreachable and not billed. Measured: 0 unreachable in 350 questions on the two keyword frames.
- **Spaces posts, profiles and answer comments are out of scope** — this Actor does questions and
  their answers.

***

### How it works

1. **Discovery** — keywords: `site:quora.com` result pages on Brave → DuckDuckGo → Bing, question
   URLs canonicalised and de-duplicated. Topics: Quora's own logged-out topic feed (GraphQL
   `TopicReadMultifeedLoggedOut_Query` → `MultifeedQuery`). Then Quora's related-question graph.
2. **Question page** — the Relay payload Quora embeds for its own front end: question, counts,
   topics, related questions, the first answers and the answer-list cursor. Merged questions (301)
   and unanswered questions (`/unanswered/`) are followed.
3. **Question stats** — the question's exact view count, creation date and merge count, from the
   GraphQL query Quora's own question-log page runs (`ContentLogPageLoadableQuery`).
4. **Answers** — Quora's own persisted GraphQL query `QuestionPagedListPaginationQuery`, paged by
   cursor as JSON, until the answer cap, Quora's own `answerCount`, or the end of the list.
5. **Billing** — each row is charged first, then pushed exactly as charged; the run asserts that no
   question was delivered twice.

**Transport**, measured from Apify's network on 2026-09-23: curl / got-scraping fingerprints get
Cloudflare's "Just a moment…" 403 on every URL; Chrome, Chrome 131 and Chrome 136 fingerprints 0 of
18 (Chrome 142: 1 of 6); a Firefox 144
fingerprint direct from Apify cleared **12 of 12** question pages and **12 of 12** GraphQL calls with
no proxy at all. That is the default rung. Challenges are retried on fresh connections; RESIDENTIAL
is the last resort because it costs ~88 KB of proxy transfer per question. One more thing we
measured and designed around: loading Quora's `/log` *pages* trips Cloudflare's per-IP limiter after
about 100 of them, after which even question pages answer HTTP 429 — so the view count and creation
date come from the log page's 3.6 KB GraphQL query instead (0 challenges in 1,174 GraphQL calls on
the two keyword frames), and the page is only a paced fallback.

Every run writes `RUN_SUMMARY` to its key-value store: delivered counts, the three kinds of nothing
kept apart (not a live question / removed by your filters / unreachable after retries), discovery
counters and per-request-type transport outcomes.

***

### Who buys this

- **Brand monitoring & social listening** — what people ask and answer about your product and your
  competitors, with the view counts that tell you which threads matter.
- **GEO / AI-visibility agencies** — Quora is one of the most-cited sources in LLM answers; find the
  high-view questions in your niche and see who answers them.
- **Content & SEO teams** — real questions with real demand (`viewCount`, `followerCount`) for FAQ
  pages, blog briefs and product copy.
- **Market research** — answer text at scale, with author credentials to weight expertise.

Its sibling: **[Reddit Search Scraper](https://apify.com/scrapersdelight/reddit-search-scraper)** —
the same mental model (keywords in, one row per post, comments nested) for Reddit.

***

### FAQ

**Do I need a Quora account?** No. Without `quoraCookie` the Actor sees what any logged-out visitor
sees. With it, only the keyword search runs under your session.

**Why do some rows have fewer answers than `answerCount`?** Quora does not serve every counted
answer to logged-out visitors. The row says so in `answersTruncated` / `answersNote`.

**Why is `viewCount` null on a row?** Its log page was not served after retries —
`statsAvailable: false` marks it. 0 of 400 on the measured frames.

**Can I get Quora's own search ranking?** Yes — paste your own Quora cookie into `quoraCookie`
("How to run it", 6). Without it, keywords are discovered through web search.

**What happens if my cookie expires?** The run falls back to web-search discovery and says so in
`RUN_SUMMARY.nativeSearch` (`status: "invalid"`). It never fails because of the cookie.

**Are the numbers rounded?** No. They are the integers Quora's API returns.

***

### Disclaimer

This Actor reads only publicly available Quora data. Answers include authors' public names and
profile links; you are responsible for how you use the extracted data. This Actor is not affiliated
with, endorsed by, or connected to Quora.

***

### Feedback

Found a question that parses wrong, or a field you need? Open an issue on the Actor's **Issues**
tab with the question URL and the run ID — every fix ships with a regression test on the real bytes.

# Actor input Schema

## `queries` (type: `array`):

One keyword phrase per line. Each is searched as site:quora.com on the open web (Brave, then DuckDuckGo, then Bing — Quora's own search is login-only), then widened through Quora's own related-question links, keeping only related questions whose title contains every word of your keyword. Questions are de-duplicated across all keywords by Quora's question id, so a question found twice is returned and billed once. Leave empty (with no URLs or topics) to run the documented sample ("web scraping").

## `questionUrls` (type: `array`):

Quora question URLs to scrape directly, one per line — e.g. https://www.quora.com/What-is-web-scraping. Answer permalinks (…/answer/Name), ?share=1 links and /unanswered/ links are accepted and resolved to their question; language editions (es.quora.com, de.quora.com, …) work too. A URL Quora has merged into another question follows the merge and returns the surviving question once.

## `topics` (type: `array`):

Topic names or topic URLs, one per line — e.g. Web Scraping or https://www.quora.com/topic/Web-Scraping. Reads the questions in the topic's logged-out feed (Quora serves roughly 30 feed items per topic to logged-out visitors), then widens through related questions.

## `quoraCookie` (type: `string`):

Paste the Cookie header from your own logged-in Quora session (it contains m-b, m-lat and similar values: open quora.com logged in, DevTools → Network, click any quora.com request, copy the whole 'cookie' request header). When set, keywords are searched with Quora's own search instead of web-search discovery; question rows and answers are still read the logged-out way. If the cookie is expired or not accepted, the run falls back to web-search discovery and says so in RUN\_SUMMARY. Leave empty to use web-search discovery.

## `maxQuestions` (type: `integer`):

Stop after this many unique questions across every keyword, URL and topic. Your hard cost cap on questions: 50 = $0.035, 1,000 = $0.70 (answers are billed separately, see below). 0 = no limit (bounded by what the search engines and Quora's related-question graph return, and the run timeout).

## `maxQuestionsPerQuery` (type: `integer`):

Cap for each keyword or topic, so one broad keyword cannot use the whole budget before the others run. Question URLs you paste are never capped by this. 0 = no per-keyword limit.

## `includeAnswers` (type: `boolean`):

Nest the question's answers into answers\[]. Turn off to get question rows only (title, counts, views, creation date, topics) — faster and cheaper.

## `maxAnswersPerQuestion` (type: `integer`):

Cap on answers nested into each question, in Quora's own ranking order. 10 answers = $0.006 per question. 1–1000. When Quora's logged-out list ends before this number, the row says so (answersTruncated + answersNote) instead of pretending the list is complete.

## `answerScope` (type: `string`):

Quora's answer list mixes in answers written to OTHER questions. "Direct" keeps only answers written to this question (the ones Quora's answerCount counts). "Direct + equivalent" also keeps answers Quora borrows from differently worded duplicate questions. "Everything Quora shows" keeps every answer on the page, including ones from merely related questions. Every answer carries a relation field either way.

## `includeAiAnswers` (type: `boolean`):

Quora pins its own AI-written answer (author "Assistant") to many questions. Off by default; when on, it is included with isAiGenerated: true and billed like any other answer.

## `expandRelated` (type: `boolean`):

After each question is read, queue the related questions Quora itself links to — but only those whose title contains every word of your keyword (for topics: every related question). This is how a keyword gets past what the web search engines return.

## `strictSearch` (type: `boolean`):

Keep only questions whose title contains EVERY word of the keyword (case-insensitive; common stop-words such as what / how / best are ignored). Web search is fuzzy, so expect fewer but on-topic rows.

## `minAnswerCount` (type: `integer`):

Skip questions with fewer answers than this, per Quora's own answerCount. 0 keeps unanswered questions too.

## `dateFrom` (type: `string`):

YYYY-MM-DD (UTC). Keeps only questions created on or after this date — the exact creation time Quora records in the question's log. A question whose creation date could not be read is dropped (and not billed) while a date window is set.

## `dateTo` (type: `string`):

YYYY-MM-DD (UTC). A bare date means the end of that day. Keeps only questions created on or before this moment.

## `includeQuestionStats` (type: `boolean`):

Reads the question's public log page for its exact view count, creation date, merge count and last-follow time — one extra request per question. Required for the date window above.

## `maxRelatedQuestions` (type: `integer`):

How many of Quora's related questions to list inside each row (relatedQuestions\[], each with its own answer count, view count and creation date). Free — they come with the page. 0–50.

## `residentialFallback` (type: `boolean`):

Quora sits behind Cloudflare. The Actor connects directly first (measured 12 of 12 question pages from Apify's network, no proxy cost), and only when a request is still challenged after retries does it move to a fresh RESIDENTIAL proxy session.

## `proxyConfiguration` (type: `object`):

Leave as is to connect directly with the RESIDENTIAL fallback above. Set your own proxy only if you must route through it — every Quora request then goes through it.

## `concurrency` (type: `integer`):

How many questions are read at the same time. Higher is faster but draws more Cloudflare challenges (each is retried, never delivered as data). 1–8.

## Actor input object example

```json
{
  "queries": [
    "web scraping"
  ],
  "questionUrls": [],
  "topics": [],
  "maxQuestions": 10,
  "maxQuestionsPerQuery": 50,
  "includeAnswers": true,
  "maxAnswersPerQuestion": 5,
  "answerScope": "direct",
  "includeAiAnswers": false,
  "expandRelated": true,
  "strictSearch": false,
  "minAnswerCount": 0,
  "dateFrom": "",
  "dateTo": "",
  "includeQuestionStats": true,
  "maxRelatedQuestions": 10,
  "residentialFallback": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  },
  "concurrency": 4
}
```

# Actor output Schema

## `items` (type: `string`):

One row per unique Quora question: qid, url, title, answer / follower / comment counts, exact view count and creation date, topics, related questions, where it was found (keyword + engine + rank, topic, URL or related), and its answers nested in answers\[] (author, credential, full text, upvotes, views, shares, comments, date, relation to the question). De-duplicated run-wide on Quora's qid, so a question found twice is billed once.

## `runSummary` (type: `string`):

RUN\_SUMMARY: delivered counts, the three kinds of nothing kept apart (not a live question / removed by your filters / unreachable after retries — none billed), discovery and transport counters.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "queries": [
        "web scraping"
    ],
    "maxQuestions": 10,
    "maxAnswersPerQuestion": 5,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapersdelight/quora-search-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "queries": ["web scraping"],
    "maxQuestions": 10,
    "maxAnswersPerQuestion": 5,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapersdelight/quora-search-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "queries": [
    "web scraping"
  ],
  "maxQuestions": 10,
  "maxAnswersPerQuestion": 5,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call scrapersdelight/quora-search-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,scrapersdelight/quora-search-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/2tlpKZVH9GE2SY3OR/builds/orS2dkR2AqqNTe2mD/openapi.json