# Quora Scraper - Questions, Answers, Upvotes & Authors (`thirdwatch/quora-scraper`) Actor

Scrape Quora questions and answers by keyword or question URL. No cookies, no login, no browser. Returns question title, follower and answer counts, full answer text, author name, profile URL and credential, upvotes, comments, views, and dates.

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

## Pricing

from $2.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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 Scraper

> **Thirdwatch portfolio:** 5K users across 88 public Actors, 2M+ records delivered, and >99% run success. [Explore all Thirdwatch Actors](https://apify.com/thirdwatch).

Scrape Quora questions and answers by keyword or by question URL. No login, no cookies, no browser. Give it a few search terms or a list of Quora question links and get back the question (title, follower count, answer count) plus every answer with its full text, author name, author profile URL, author credential, upvotes, comment count, views, shares and dates.

Built for people who need Quora as a data source rather than a website: market researchers mining what customers actually ask, SEO teams looking for question-shaped keywords, founders validating demand, analysts tracking sentiment about a product or brand, and anyone assembling a question-and-answer corpus for LLM training or retrieval.

### What you get

Two record types land in the same dataset. Each is billed as one result.

#### `question` records

One per question page scraped.

| Field | Description |
|---|---|
| `type` | Always `question` |
| `question_id` | Quora's numeric question id |
| `question_title` | Plain-text question title |
| `question_url` | Canonical question URL |
| `question_follower_count` | Number of people following the question |
| `question_answer_count` | Number of answers written directly to this question |
| `question_total_answer_count` | Answers Quora shows on the page including answers merged in from equivalent questions |
| `search_query` | The keyword that found this question (null for direct URLs) |
| `search_rank` | Position in the keyword results (1 = first) |
| `search_engine` | Which discovery engine returned it |
| `scraped_at` | ISO 8601 UTC timestamp |

#### `answer` records

One per answer, up to `maxAnswersPerQuestion` per question.

| Field | Description |
|---|---|
| `type` | Always `answer` |
| `question_id`, `question_title`, `question_url` | The question this answer was collected from |
| `question_follower_count`, `question_answer_count` | Same counts as the question record, repeated for convenience |
| `answer_id` | Quora's numeric answer id |
| `answer_url` | Permalink to the answer |
| `answer_text` | Full answer as plain text. Paragraphs separated by newlines; list items prefixed with `- `; quotes prefixed with `> ` |
| `author_name` | Display name, or `Anonymous` |
| `author_profile_url` | `https://www.quora.com/profile/...` (null for anonymous authors) |
| `author_credential` | The credential line Quora shows under the name, e.g. "Software Engineer at Google (2015-present)" |
| `author_is_verified` | Quora verified badge |
| `author_is_anonymous` | True when the author posted anonymously |
| `is_ai_answer` | True for Quora's machine-generated "Assistant" answers (skipped unless `includeAiAnswers` is on) |
| `is_related_answer` | True when Quora surfaced this answer from an equivalent/merged question rather than the page's own question |
| `source_question_title`, `source_question_url` | For related answers: the question it was originally written for |
| `upvotes` | Upvote count |
| `comments_count` | Number of comments shown on the answer |
| `views` | View count |
| `shares` | Share count |
| `date` | Answer creation time (ISO 8601 UTC) |
| `updated_date` | Last edit time (ISO 8601 UTC) |
| `search_query`, `search_rank`, `scraped_at` | Provenance, as above |

### Input

```json
{
  "searchQueries": ["best way to learn Python", "is Notion worth it"],
  "questionUrls": ["https://www.quora.com/As-an-intermediate-Python-programmer-how-can-I-take-my-skills-to-the-next-level"],
  "maxQuestionsPerQuery": 10,
  "maxAnswersPerQuestion": 20,
  "includeAiAnswers": false
}
```

| Parameter | Type | Default | Notes |
|---|---|---|---|
| `searchQueries` | array of strings | `[]` | Keywords. Each one is resolved to up to `maxQuestionsPerQuery` Quora question pages |
| `questionUrls` | array of strings | `[]` | Direct question links. Answer permalinks (`/answer/Author-Name`) are accepted and mapped back to the question. Regional subdomains such as `es.quora.com` work |
| `maxQuestionsPerQuery` | integer | `10` | 1 to 100 |
| `maxAnswersPerQuestion` | integer | `20` | 0 to 500. Set `0` to collect question records only, which is the cheapest way to turn keywords into a list of Quora questions |
| `includeAiAnswers` | boolean | `false` | Keep Quora's auto-generated "Assistant" answers |
| `proxyConfiguration` | object | Apify residential, US | Quora is IP-sensitive. Residential is the safe default; datacenter proxies may work for small runs |

You must supply at least one search query or one question URL. Both can be combined in one run; URLs are de-duplicated against search hits.

### How it works

Quora renders question pages on the server and embeds the first answers, the question title, follower count and answer count as JSON inside the page. The actor fetches the page over HTTP with a Chrome-shaped TLS fingerprint (no browser is launched), reads that embedded data, and then pages through the remaining answers using the same internal endpoint Quora's own front end calls when you scroll. The endpoint is called anonymously with the per-page form key and the session cookie Quora sets on the first response, so no account, cookie export or login is needed from you.

Quora's on-site search is only available to logged-in users (the search page redirects anonymous visitors to the homepage, and the underlying search API returns nothing for them). Keyword queries are therefore resolved through public web search restricted to `quora.com` and the matching question pages are then scraped directly. In practice this returns the same high-traffic questions that Quora's own search would rank first, but the ordering is the search engine's, not Quora's, and the `Question / Answer / Profile / Space` type filters of Quora's native search are not available.

Each question costs one page request plus roughly one request per 8-10 additional answers. A 2-3 second pause is kept between requests and 429/503 responses back off exponentially. A blocked question page is retried once on a fresh proxy session before being counted as blocked.

### Why answers may be fewer than the question's answer count

- `question_answer_count` counts answers written directly to that question, while Quora's page also mixes in answers from equivalent questions; the mixed list is what gets scraped and each record says which case it is via `is_related_answer`.
- Quora's AI "Assistant" answers are skipped unless you enable `includeAiAnswers`.
- Collapsed, deleted, or moderation-hidden answers are not served to anonymous visitors.
- `maxAnswersPerQuestion` caps the count.

### Zero results and failures

The run stays honest about what happened:

- Keyword found no Quora questions: the run succeeds with a warning and no records for that keyword.
- Question URL returns 404 or bounces to the homepage (removed or merged question): counted as not found, run continues.
- Quora or the search engines could not be reached for any target: the run **fails** with a status message instead of quietly succeeding with an empty dataset, so a scheduled run does not silently degrade.

### Use cases

**Keyword and content research.** Quora questions are literal user intent. Run your seed topics through `searchQueries` with `maxAnswersPerQuestion: 0` to harvest hundreds of question-shaped keywords with follower counts as a demand signal, then scrape the answers for the ones worth writing about.

**Product and market research.** Search a category ("best CRM for small business", "alternatives to X") and read what real users recommend, complain about and compare. `upvotes` and `views` tell you which opinions the community endorses.

**Brand and reputation monitoring.** Schedule daily runs on your brand and competitor names. New answers appear with their `date`, author and credential, so you can respond or escalate.

**Expert sourcing.** Filter answers by `author_credential` and `upvotes` to find practitioners in a niche, with profile URLs ready for outreach.

**LLM and RAG datasets.** Clean question/answer pairs with engagement signals and timestamps, ready to embed. Answers are plain text, not HTML.

### Tips

- Start with `maxAnswersPerQuestion: 0` to preview which questions a keyword returns before paying for answers.
- Very long-tail keywords sometimes return nothing; broaden the phrasing or drop qualifiers.
- If you already know the question URLs (from Google, a sitemap, a previous run), pass them directly; this skips discovery and is faster.
- For thousands of questions, split across multiple runs or raise the run timeout; each question takes about 3-8 seconds including pagination.

### Integrations

Runs on the Apify platform, so you can trigger it via API, schedule it, chain it with other actors, and export the dataset as JSON, CSV, Excel or push it to Google Sheets, Airtable, Zapier, Make and webhooks.

```bash
curl -X POST "https://api.apify.com/v2/acts/thirdwatch~quora-scraper/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"searchQueries": ["best way to learn Python"], "maxQuestionsPerQuery": 5, "maxAnswersPerQuestion": 10}'
```

### Legal

This actor collects only publicly visible content that Quora serves to anonymous visitors. Answers and questions are user-generated and belong to their authors; make sure your use complies with Quora's terms, applicable copyright law and data-protection rules (GDPR, CCPA) for any personal data such as author names.

### Other Thirdwatch actors you may need

[Reddit Scraper](https://apify.com/thirdwatch/reddit-scraper) for the other big discussion source, [Google Search Scraper](https://apify.com/thirdwatch/google-search-scraper) for SERP data, [Trustpilot Scraper](https://apify.com/thirdwatch/trustpilot-scraper) and [G2 Scraper](https://apify.com/thirdwatch/g2-scraper) for structured reviews. See [all Thirdwatch actors](https://apify.com/thirdwatch).

### Output fields

- One row per result with stable keys.

### Limitations

- Results reflect the public source at run time; removed or restricted items disappear between runs.
- Fields that are not publicly disclosed stay empty rather than being guessed.
- Use public data lawfully and respect applicable privacy and platform rules.

Last verified: 2026-09

More scrapers at [thirdwatch.dev](https://thirdwatch.dev).

# Actor input Schema

## `searchQueries` (type: `array`):

Keywords to find Quora questions for (e.g. 'best way to learn Python', 'is Notion worth it'). Each query is resolved to Quora question pages, then every question is scraped for answers. Leave empty if you only pass Question URLs.

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

Direct Quora question URLs to scrape, e.g. https://www.quora.com/What-is-the-best-way-to-learn-Python. Answer permalinks (.../answer/Author-Name) are accepted and resolved to their question. Regional subdomains (es.quora.com, fr.quora.com) work too.

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

How many Quora questions to collect for each search query. Each question then costs one page fetch plus pagination for its answers.

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

Maximum answers to scrape per question. Set to 0 to collect question records only (title, URL, follower and answer counts) without fetching answers.

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

Quora injects machine-generated answers by its 'Assistant' account on many questions. They are skipped by default; enable to keep them (flagged with is_ai_answer = true).

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

Apify Proxy settings. Quora and the search engines used for keyword discovery are IP-sensitive; residential proxies are the safe default.

## Actor input object example

```json
{
  "searchQueries": [
    "best way to learn Python"
  ],
  "questionUrls": [
    "https://www.quora.com/As-an-intermediate-Python-programmer-how-can-I-take-my-skills-to-the-next-level"
  ],
  "maxQuestionsPerQuery": 10,
  "maxAnswersPerQuestion": 20,
  "includeAiAnswers": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# 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 = {
    "searchQueries": [
        "best way to learn Python"
    ],
    "questionUrls": [
        "https://www.quora.com/As-an-intermediate-Python-programmer-how-can-I-take-my-skills-to-the-next-level"
    ],
    "maxQuestionsPerQuery": 10,
    "maxAnswersPerQuestion": 20,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("thirdwatch/quora-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 = {
    "searchQueries": ["best way to learn Python"],
    "questionUrls": ["https://www.quora.com/As-an-intermediate-Python-programmer-how-can-I-take-my-skills-to-the-next-level"],
    "maxQuestionsPerQuery": 10,
    "maxAnswersPerQuestion": 20,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("thirdwatch/quora-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 '{
  "searchQueries": [
    "best way to learn Python"
  ],
  "questionUrls": [
    "https://www.quora.com/As-an-intermediate-Python-programmer-how-can-I-take-my-skills-to-the-next-level"
  ],
  "maxQuestionsPerQuery": 10,
  "maxAnswersPerQuestion": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}' |
apify call thirdwatch/quora-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,thirdwatch/quora-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/zQnSzqKNDYMOdKX8t/builds/iaTs8QSMw4UiIx969/openapi.json