# Quora Scraper API - Answers, Authors, Upvotes & Views (`scrapifier/quora-scraper`) Actor

💬 Scrape Quora answers by question URL, profile URL or topic. Get the full answer text, author name and profile, credentials, upvotes, views, shares, comments count, the question, dates and media, as clean structured data. No login and no cookies needed. Pay per result.

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

## Pricing

from $0.61 / 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 API - Answers, Authors, Upvotes & Views

Scrape Quora answers from any question URL or profile URL and export them as JSON, CSV or Excel, or pull them straight from the API.

⚡ For every answer you get the **full answer text** rendered as readable plain text, the **author** (name, profile URL, Quora user id, anonymous flag), the **upvotes**, **views** and shares, the word count, the **question it belongs to** (title, URL, answer count), the creation and last-update dates and a deleted flag. Paste a question URL to collect every answer to that question, or a profile URL to collect the answers one person has written. Works with **no login, no cookies and no proxy**. You **pay per answer**.

[![Apify Actor](https://apify.com/actor-badge?actor=scrapifier/quora-scraper)](https://apify.com/scrapifier/quora-scraper)

### 🎯 Why scrape Quora answers?

- **Market and consumer research**: read how real people describe a problem, a product category or a buying decision in their own words, across hundreds of answers instead of a handful of survey responses.
- **Content marketing and SEO**: mine the questions people actually ask and the answers that get the most upvotes to plan articles, FAQs and landing pages that match search intent.
- **Brand and competitor monitoring**: collect every answer that mentions your brand or a competitor, with upvotes and views, to see which opinions are gaining traction.
- **Expert and lead sourcing**: pull the answers written by a Quora user to qualify potential experts, partners or influencers by the topics they cover and the engagement they get.
- **NLP and academic research**: build datasets of long-form opinion text with dates, engagement metrics and authorship for sentiment analysis, topic modelling or discourse studies.
- **Product and support teams**: track recurring complaints, workarounds and feature requests about your product as they are discussed publicly.

### 📊 What data does Quora Answers Scraper extract?

| Field | Description |
|---|---|
| `answerId` | Unique Quora answer id |
| `url` | Direct link to the answer on Quora |
| `content` | The full answer text, rendered from Quora's rich text into plain text (lists become one line per item) |
| `wordCount` | Number of words in `content` |
| `numViews` | View count |
| `numUpvotes` | Upvote count |
| `numShares` | Share count |
| `creationTime` | When the answer was written (ISO 8601, UTC) |
| `updatedTime` | When the answer was last updated (ISO 8601, UTC) |
| `isDeleted` | `true` when Quora marks the answer as deleted |
| `author.name`, `author.url`, `author.uid`, `author.isAnonymous` | The author's display name, profile URL, numeric user id and anonymity flag |
| `question.qid`, `question.title`, `question.url`, `question.answerCount` | The question the answer belongs to, when `includeQuestion` is on |
| `contentRaw` | Quora's original rich-text JSON (sections and spans), only when `includeRawContent` is on |
| `authorName`, `authorUrl`, `questionTitle` | Flat columns replacing the `author` and `question` objects, only when `flatten` is on |

With `flatten` enabled the nested `author` and `question` objects are dropped and replaced by the three flat columns, so CSV and Excel exports stay one row per answer with no nested cells.

### 🚀 How to scrape Quora answers

1. Open the Actor and paste one or more **Quora URLs** in `startUrls`: a question URL such as `https://www.quora.com/What-is-the-best-way-to-learn-programming`, or a profile URL such as `https://www.quora.com/profile/Adam-DAngelo`. You can mix both in one run.
2. Set **Max answers per URL** (`maxAnswersPerItem`). The default is `50`; `0` collects as many answers as Quora exposes for that question or profile.
3. Keep **Include question details** on if you want the question title, URL and answer count attached to each answer. Turn on **Flat columns** if you plan to open the result in Excel, and **Include raw content** if you need Quora's original rich-text structure.
4. Click **Start**. The Actor collects the answers 20 at a time until the cap or the end of the list.
5. Open the **Storage** tab to preview the answers and export them as JSON, CSV, Excel or XML, or read them from the dataset API.

The same run can be started from the Apify API, the Python or JavaScript client, or put on a schedule to follow a question or an author over time.

### 📥 Input parameters

| Field | Key | Type | Default | Description |
|---|---|---|---|---|
| Quora URLs | `startUrls` | array of URLs | `[{ "url": "https://www.quora.com/What-is-the-best-way-to-learn-programming" }]` | Question URLs (every answer to the question) and/or profile URLs (every answer written by that person). |
| Max answers per URL | `maxAnswersPerItem` | integer | `50` | Answers to collect per question or per profile. `0` = as many as Quora exposes. |
| Include question details | `includeQuestion` | boolean | `true` | Attach the question (id, title, URL, answer count) to every answer. |
| Include raw content | `includeRawContent` | boolean | `false` | Add a `contentRaw` field with Quora's original rich-text JSON next to the readable text. |
| Flat columns (CSV-friendly) | `flatten` | boolean | `false` | Replace the nested `author` and `question` objects with `authorName`, `authorUrl` and `questionTitle` columns. |
| Report empty inputs | `emitInputStatus` | boolean | `true` | Write an `input_status` report (which URL returned nothing and why) to the run's OUTPUT record. |
| Page load retries | `maxChallengeRetries` | integer | `6` | Retries when a page fails to load. Increase only if runs report being blocked. |
| Proxy | `proxyConfiguration` | object | `{ "useApifyProxy": false }` | Leave off. A proxy usually makes Quora runs fail; only add one if you have your own clean, ISP-grade IPs. |

Example input:

```json
{
  "startUrls": [
    { "url": "https://www.quora.com/What-is-the-best-way-to-learn-programming" },
    { "url": "https://www.quora.com/profile/Adam-DAngelo" }
  ],
  "maxAnswersPerItem": 50,
  "includeQuestion": true
}
```

Any URL containing `/profile/` is treated as a profile and the Actor reads that user's answers list (a pasted `.../profile/<name>/answers` URL works too). Every other Quora URL is treated as a question: the path is kept and any query string or fragment is dropped, so you can paste a question link copied from a browser as is.

### 📤 Output example

Each answer is one dataset item, exportable as JSON, CSV, Excel or via the API.

```json
{
  "answerId": 630508,
  "url": "https://www.quora.com/Whats-the-best-way-to-learn-how-to-program/answer/Zed-A.-Shaw",
  "content": "If you've got experience programming then making something with a new language does work…",
  "wordCount": 210,
  "numViews": 8232,
  "numUpvotes": 49,
  "numShares": 0,
  "creationTime": "2013-05-02T18:41:10Z",
  "author": { "name": "Zed A. Shaw", "url": "https://www.quora.com/profile/Zed-A-Shaw", "isAnonymous": false },
  "question": { "title": "What's the best way to learn how to program?", "url": "https://www.quora.com/Whats-the-best-way-to-learn-how-to-program", "answerCount": 42 }
}
```

The run's OUTPUT record holds the run statistics (`unique_answers`, `duplicates`, `requests`, `errors`) and, when `emitInputStatus` is on, one `input_status` entry per URL with its kind (`question` or `profile`), the number of answers collected and a status of `ok`, `empty`, `load_failed` or `error`, so you can see at a glance which input produced nothing.

### 💡 Ready-to-run examples

**Every answer to one question**

```json
{ "startUrls": [{ "url": "https://www.quora.com/What-is-the-best-way-to-learn-programming" }], "maxAnswersPerItem": 0 }
```

**The 50 most recent answers written by one Quora user**

```json
{ "startUrls": [{ "url": "https://www.quora.com/profile/Adam-DAngelo" }], "maxAnswersPerItem": 50 }
```

**A question and a profile in one run, flat columns for Excel**

```json
{ "startUrls": [{ "url": "https://www.quora.com/What-is-the-best-way-to-learn-programming" }, { "url": "https://www.quora.com/profile/Adam-DAngelo" }], "maxAnswersPerItem": 50, "includeQuestion": true, "flatten": true }
```

**Answers with Quora's original rich-text structure**

```json
{ "startUrls": [{ "url": "https://www.quora.com/What-is-the-best-way-to-learn-programming" }], "maxAnswersPerItem": 50, "includeRawContent": true }
```

### 💰 Pricing: how much does it cost to scrape Quora?

From **$0.90 per 1,000 answers** on the free plan, with automatic volume discounts down to **$0.61 per 1,000** on higher Apify plans. You pay only for the results you receive, there is no subscription and no start fee. New Apify accounts get free monthly platform credits to try it.

Cost is driven purely by the number of answers returned: `maxAnswersPerItem` caps each question or profile, so a run with three URLs and a cap of `50` costs at most 150 answers. Set it to `0` only once you know how many answers a question or author has.

### ⚙️ Performance, proxies and limits

- **No proxy needed, and not recommended.** The Actor collects 20 answers per request. Leave `proxyConfiguration` off unless you own clean, ISP-grade IPs.
- **Speed**: answers are fetched 20 at a time and pushed to the dataset in batches of 200.
- **Retries**: each page load waits up to 45 seconds and is retried up to `maxChallengeRetries` times (default `6`) if it fails to load. A URL that never loads is reported as `load_failed` in `input_status`.
- **Memory**: the default run configuration uses 4096 MB and a 3600 second timeout.
- **Pagination**: the Actor pages through and stops when the cap is reached, when there are no further pages, or when a page brings no new answer.
- **Deduplication**: answers are deduplicated by `answerId` within each URL; duplicates Quora returns across pages are counted in the run statistics and not billed twice.
- **Volume**: `0` in `maxAnswersPerItem` collects everything Quora exposes for that question or profile. Very popular questions can have hundreds of answers, so keep a cap for a first run.
- **Supported URLs**: question pages and profile pages only. Topic and Space URLs are not supported.

### 🔌 Integrations and API

Run Quora Answers Scraper from the [Apify API](https://docs.apify.com/api/v2), the [Python](https://docs.apify.com/api/client/python) or [JavaScript](https://docs.apify.com/api/client/js) client, or on a [schedule](https://docs.apify.com/platform/schedules). Connect it to Make, Zapier, n8n, Google Sheets, Slack or any webhook through [Apify integrations](https://apify.com/integrations). Every run's dataset is available as JSON, CSV, Excel or XML from the dataset API.

```bash
curl -X POST "https://api.apify.com/v2/acts/scrapifier~quora-scraper/run-sync-get-dataset-items?token=<YOUR_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{ "startUrls": [{ "url": "https://www.quora.com/What-is-the-best-way-to-learn-programming" }], "maxAnswersPerItem": 50, "includeQuestion": true }'
```

### ❓ FAQ

**Is it legal to scrape Quora answers?**

The Actor only reads answers that Quora publishes to anyone without logging in. Answers carry personal data (author names, profile URLs), so process them in line with GDPR and other privacy laws, respect Quora's terms of service, and stay responsible for how you use the data. This is not legal advice.

**Do I need a Quora account, login or cookies?**

No. Nothing to log in to, no cookies to paste, no proxy to configure. The Actor handles everything on its own.

**Which Quora URLs are supported?**

Question URLs (`https://www.quora.com/<question-slug>`) and profile URLs (`https://www.quora.com/profile/<name>`). A question URL returns every answer to that question; a profile URL returns the answers that person has written, most recent first. Topic and Space URLs are not supported.

**Can I export Quora answers to Excel or Google Sheets?**

Yes. Every run's dataset downloads as CSV, XLSX, JSON or XML from the Storage tab, and the Google Sheets integration can push new answers to a sheet automatically. Turn on `flatten` to get one clean row per answer with `authorName`, `authorUrl` and `questionTitle` columns.

**How many answers can I scrape per question or profile?**

As many as Quora exposes (set `maxAnswersPerItem` to `0`). The default cap is `50` per URL; add several question or profile URLs to one run to collect in bulk.

**What does the answer text look like?**

`content` is plain text rendered from Quora's rich-text format: paragraphs are separated by line breaks and list items become one line each. If you need the original structure (sections, spans, indentation), enable `includeRawContent` to get the `contentRaw` field.

**My run reports being blocked or returns nothing. What should I do?**

Check the `input_status` report in the run's OUTPUT record: `load_failed` means the page never loaded, `empty` means the page loaded but Quora returned no answers. Make sure `proxyConfiguration` is off, then retry later or raise `maxChallengeRetries`.

**How fresh is the data?**

Every run scrapes Quora live. Schedule the Actor daily or weekly to follow a question, a topic's key questions or an author over time.

### 🔗 Related scrapers

- [Trustpilot Reviews Scraper](https://apify.com/scrapifier/trustpilot-reviews-scraper): customer reviews and TrustScores for any company.
- [Glassdoor Reviews Scraper](https://apify.com/scrapifier/glassdoor-reviews-scraper): employee reviews with ratings, pros, cons and company responses.
- [Glassdoor Interviews Scraper](https://apify.com/scrapifier/glassdoor-interviews-scraper): interview experiences and the questions asked, by company.
- [Glassdoor Company Overview Scraper](https://apify.com/scrapifier/glassdoor-company-scraper): the full company profile by name or URL.
- [Vinted Scraper](https://apify.com/scrapifier/vinted-scraper): second-hand fashion listings from any Vinted country.

### 💬 Support

Questions, bugs or a feature request? Open an issue in the **Issues** tab of this Actor, I answer quickly. If Quora Answers Scraper saves you time, a rating on the Store helps others find it.

# Actor input Schema

## `startUrls` (type: `array`):

Paste one or more Quora URLs. A question URL (e.g. https://www.quora.com/What-is-the-best-way-to-learn-programming) collects every answer to that question. A profile URL (e.g. https://www.quora.com/profile/Adam-DAngelo) collects the answers that person has written.

## `maxAnswersPerItem` (type: `integer`):

How many answers to collect per question / per profile (0 = as many as Quora exposes).

## `includeQuestion` (type: `boolean`):

Attach the question (title, URL, answer count) to every answer.

## `includeRawContent` (type: `boolean`):

Also include Quora's original rich-text content structure alongside the readable text.

## `flatten` (type: `boolean`):

Add flat authorName / authorUrl / questionTitle columns (drops the nested objects) for clean CSV/Excel exports.

## `emitInputStatus` (type: `boolean`):

Add an input_status report to the run's OUTPUT record.

## `maxChallengeRetries` (type: `integer`):

How many retry attempts if a page fails to load. Increase only if runs report being blocked.

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

Leave OFF (recommended). A proxy usually makes Quora runs fail, the Actor works best without one. Only add a proxy if you have your own clean, ISP-grade IPs.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.quora.com/What-is-the-best-way-to-learn-programming"
    }
  ],
  "maxAnswersPerItem": 50,
  "includeQuestion": true,
  "includeRawContent": false,
  "flatten": false,
  "emitInputStatus": true,
  "maxChallengeRetries": 6,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `answers` (type: `string`):

All Quora answers extracted by this run.

# 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 = {
    "startUrls": [
        {
            "url": "https://www.quora.com/What-is-the-best-way-to-learn-programming"
        }
    ],
    "maxAnswersPerItem": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapifier/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 = {
    "startUrls": [{ "url": "https://www.quora.com/What-is-the-best-way-to-learn-programming" }],
    "maxAnswersPerItem": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("scrapifier/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 '{
  "startUrls": [
    {
      "url": "https://www.quora.com/What-is-the-best-way-to-learn-programming"
    }
  ],
  "maxAnswersPerItem": 50
}' |
apify call scrapifier/quora-scraper --silent --output-dataset

```

## MCP server setup

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