# Quora Scraper — Questions, Answers & Profiles (`tortuga/quora-scraper`) Actor

Scrape Quora answers with full text, upvotes, views, shares, author and credential from question, topic and profile URLs, plus comments. No login.

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

## Pricing

from $0.70 / 1,000 answers

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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 — Questions, Answers & Profiles

Scrape Quora answers with full text, upvotes, views, shares, author and credential from question, topic and profile URLs, plus comments. No login.

Quora Scraper reads Quora the way a logged-out visitor sees it and turns it into a clean dataset. Paste a **question URL** and get its answers, page after page, each with the **full answer text** (plain text and HTML), **upvotes, views, shares and comment count**, the **date written and last edited**, the **author's name, profile URL and credential** ("Software developer", "Studied at MIT"...), and the question's title, URL, answer count, follower count and topics. Paste a **profile URL** for the author's profile (followers, answer count, content views, credentials, bio) plus their most recent answers, or a **topic URL** for the answers Quora features in that topic. Switch on comments to get the discussion under every answer. Download JSON, CSV or Excel, or call it from Python, Node, n8n, Make or Google Sheets. You pay only for the items you get; no Quora account, cookies or API key needed.

### What data does Quora Scraper extract?

Every item has a `type` field: `answer`, `profile` or `comment`.

#### Answer items (`type: "answer"`)

| Field | Description |
|---|---|
| `id`, `answerUrl` | Quora answer ID and permalink |
| `questionId`, `questionTitle`, `questionUrl` | The question the answer belongs to |
| `questionAnswerCount`, `questionFollowerCount`, `questionCommentCount`, `questionTopics` | Question stats and topic names (follower/comment counts and topics on question URLs) |
| `text`, `html` | Full answer text: plain text (lists as `- item`, images as `[image: url]`) and simple HTML |
| `authorName`, `authorProfileUrl`, `authorId` | The author as shown on the answer ("Anonymous" for anonymous answers, no profile link) |
| `authorCredential` | The credential line shown next to the author's name on this answer |
| `authorImageUrl`, `authorIsVerified` | Profile photo and verified badge |
| `authorAnswerCount`, `authorTotalViews` | Author stats Quora shows under the answer (when present) |
| `upvotes`, `views`, `shares`, `comments` | Engagement counters as shown |
| `createdAt`, `updatedAt` | ISO 8601 date the answer was written / last edited |
| `isPreviewOnly` | `true` for Quora+ (paid) answers: logged-out visitors only see the opening paragraphs, so `text` is that preview |
| `isRelatedAnswer` | `true` for answers to other, equivalent questions that Quora lists under this question (only with **Include related answers**) |
| `originalQuestionTitle` | Set when the answer was written for a question Quora later merged into this one |
| `topic` | Topic name (answers from topic URLs only) |
| `sourceUrl`, `scrapedAt` | Start URL that produced the item and collection time |

#### Profile items (`type: "profile"`, profile URLs)

`userId`, `name`, `profileUrl`, `credential`, `bio`, `followers`, `following`, `answerCount`, `questionCount`, `postCount`, `totalContentViews`, `lastMonthContentViews`, `imageUrl`, `isVerified`, `workCredentials`, `schoolCredentials`, `locationCredentials`, `joinedAt`.

#### Comment items (`type: "comment"`, with **Include comments**)

`commentId`, `answerId`, `parentCommentId`, `isReply`, `text`, `authorName`, `authorProfileUrl`, `upvotes`, `createdAt`, `commentUrl`, `answerUrl`, `questionTitle`, `questionUrl`.

### How to use Quora Scraper

1. Paste English Quora (`www.quora.com`) URLs into **Quora URLs**, one per line: questions (`https://www.quora.com/How-do-I-learn-Python-programming`), single answers (`.../answer/Author-Name`), topics (`https://www.quora.com/topic/Python-programming-language-1`) or profiles (`https://www.quora.com/profile/Alan-Mellor`).
2. Set **Max answers per question** and **Max items** to cap the run and the cost.
3. Optionally switch on **Include comments**, or **Open the questions found on topic and profile pages** to turn a topic into hundreds of answers.
4. Click **Start**. Results appear in the **Dataset** tab (views: Answers, Profiles, Comments); export from there or use the API.

### Input example

```json
{
  "startUrls": [
    { "url": "https://www.quora.com/How-do-I-learn-Python-programming" },
    { "url": "https://www.quora.com/profile/Alan-Mellor" },
    { "url": "https://www.quora.com/topic/Python-programming-language-1" }
  ],
  "maxAnswersPerQuestion": 200,
  "maxItems": 500,
  "includeComments": false
}
```

### Output example

```json
{
  "type": "answer",
  "id": 17608264,
  "answerUrl": "https://www.quora.com/How-should-I-start-learning-Python-1/answer/Scott-Robinson-25",
  "questionId": 1070353,
  "questionTitle": "How should I start learning Python?",
  "questionUrl": "https://www.quora.com/How-should-I-start-learning-Python-1",
  "questionAnswerCount": 915,
  "questionFollowerCount": 7252,
  "questionCommentCount": 59,
  "questionTopics": ["Education", "Python (programming language)", "Software Development", "Learning to Program"],
  "text": "When I'm learning something new, like a new language or framework, there are a few approaches you can take.\nOption 1: A structured course\n...",
  "html": "<p>When I&#x27;m learning something new, ...</p><p><b>Option 1: A structured course</b></p>...",
  "authorName": "Scott Robinson",
  "authorProfileUrl": "https://www.quora.com/profile/Scott-Robinson-25",
  "authorId": 17256841,
  "authorCredential": "Software developer",
  "authorImageUrl": "https://qph.cf2.quoracdn.net/main-thumb-17256841-200-eqvxwapxivusqlufqyfevswcmxasxemi.jpeg",
  "authorIsVerified": false,
  "authorAnswerCount": 82,
  "authorTotalViews": 775490,
  "upvotes": 27,
  "views": 8111,
  "shares": 0,
  "comments": 0,
  "createdAt": "2015-12-07T13:09:56.739641Z",
  "updatedAt": null,
  "isMachineAnswer": false,
  "isPreviewOnly": false,
  "isRelatedAnswer": false,
  "originalQuestionTitle": "How should I go about learning Python?",
  "sourceUrl": "https://www.quora.com/How-do-I-learn-Python-programming",
  "scrapedAt": "2026-10-10T01:00:32Z"
}
```

### How to scrape all answers to a Quora question

Paste the question URL and set **Max answers per question** above the question's answer count (shown in `questionAnswerCount`). The Actor reads the answers embedded in the page, then asks Quora for the next 10 answers again and again, exactly like the page does when you scroll, until the question runs out of answers or your limit is reached. Answers come in Quora's own ranking order. Quora mixes "related answers" to other, equivalent questions into the answer list and adds an AI-bot answer to some questions. By default both are skipped, so every item is a real answer to the question you asked for; switch on **Include related answers** to get the related ones too (`isRelatedAnswer: true`, with the question they were written for). Some popular questions are mostly made of related answers for logged-out visitors (for example "What is the meaning of life?"), so turn it on there.

### Does it work without a Quora account?

Yes. No login, cookies or API key are involved. That has two consequences you should know about. First, **Quora's keyword search only works for logged-in users**, so this Actor starts from URLs, not search terms: find questions with Quora or Google and paste their URLs, or start from a topic or profile and switch on **Open the questions found on topic and profile pages**. Second, Quora shows logged-out visitors a limited slice of some lists: a profile shows the **30 most recent answers** and a topic feed about **20 featured answers**. Question pages have no such limit, and the full answer text is returned, not the truncated preview; only Quora+ (paid) answers stay a preview, marked `isPreviewOnly: true`.

### How to scrape a Quora profile and its answers

Paste the profile URL (`https://www.quora.com/profile/Name`). You get one `profile` item (name, credential, bio, followers, following, answer/question/post counts, all-time and last-month content views, work/school/location credentials, join date) and the author's most recent answers as `answer` items. Switch on **Open the questions found on topic and profile pages** to also collect the other answers to the questions they answered.

### Monitor changes on a schedule

Turn on **Only new answers** to get a feed of new answers: each run remembers the answers (and profiles and comments) earlier runs of the same input returned and outputs only the ones it has not seen before. Answers already seen are dropped before they are saved, so they are not charged, and their comments are not fetched again. Profiles list answers newest first, so watching an author costs one request when nothing changed; on a question, keep **Max answers per question** above its answer count so a new answer is found wherever Quora ranks it. Save the input as a task and add a Schedule in Apify (for example daily); give each watch its own **Monitoring key** if several schedules use the same URLs. Every output item then has `changeType: "new"`; upvotes and views are not tracked, so `previousValues` does not appear.

### What does it cost?

Pay per item: **$0.70 per 1,000 answers or profiles** and **$0.50 per 1,000 comments**, no start fee and no subscription. Apify's free plan is enough to export a few thousand answers.

**Proxy note:** Quora is behind Cloudflare, which challenges many datacenter IPs, so the default proxy is Apify Residential. It is billed by traffic on your Apify account, but Quora's responses are compressed: our test runs used 5-6 KB of residential traffic per item, and the whole platform usage (compute + proxy) came to $0.06-0.08 per 1,000 items. Datacenter proxy works for some requests but often fails on profile and answer pages.

### Integrations and API

Use the run in Zapier, Make, n8n, Google Sheets, or call it from Python/Node with the Apify client. See the **API** tab for ready-made snippets. The dataset feeds LLM and RAG pipelines directly: `text` is clean plain text, `html` keeps the formatting.

### Is it legal to scrape Quora?

This Actor collects only what Quora shows to anyone without an account: questions, answers, public profiles and comments. It does not log in and never reads content behind Quora's sign-up wall, Quora+ paywalls or private Spaces. Author and commenter names, profile links and credentials are the public bylines Quora prints next to every answer; anonymous answers stay anonymous. You are responsible for how you use the data and for complying with Quora's terms and applicable law.

### Support

Found a bug or need a field added? Open an issue in the **Issues** tab; it is usually answered within a day.

# Actor input Schema

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

Quora pages to scrape, one per line. Question URL (`https://www.quora.com/How-do-I-learn-Python`): its answers. Answer URL (`.../answer/Author-Name`): that answer. Topic URL (`https://www.quora.com/topic/Python-programming-language-1`): the ~20 answers Quora's topic feed shows logged-out visitors. Profile URL (`https://www.quora.com/profile/Name`): the profile plus the author's 30 most recent answers.

## `maxItems` (type: `integer`):

Overall cap on dataset items for the run (answers + profiles + comments). You pay per item, so this keeps the cost predictable.

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

How many answers to read from each question, in Quora's own ranking order (10 per request). Popular questions have hundreds of answers.

## `includeRelatedAnswers` (type: `boolean`):

Logged-out visitors see answers to other, equivalent questions mixed into a question's answer list ("Related answers"). Off: only answers to the question itself. On: those too, marked `isRelatedAnswer: true` and carrying the question they were written for. They count toward Max answers per question.

## `followQuestions` (type: `boolean`):

For topic and profile URLs: also open the question of every answer found there and collect that question's answers (up to Max answers per question). Turns a topic into a much larger answer set.

## `includeComments` (type: `boolean`):

Also save `comment` items for every answer: top-level comments plus the first replies Quora shows under them (one extra request per 10 comments).

## `maxCommentsPerAnswer` (type: `integer`):

Cap on comments (including the inlined replies) saved per answer when comments are included.

## `onlyNewOrChanged` (type: `boolean`):

Remember which answers earlier runs of this input returned and output only answers (and profiles) not seen before. Use with a Schedule to watch questions, topics or authors for new answers; answers already seen are not charged and their comments are not fetched again.

## `monitoringKey` (type: `string`):

Name for this watch, so several schedules on the same URLs stay separate; defaults to a key derived from the input

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

Quora sits behind Cloudflare, which challenges many datacenter IPs. Residential proxy (default) works reliably; it is billed by traffic on your account, about 5-10 KB per answer (well under $0.10 per 1,000 answers).

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.quora.com/How-do-I-learn-Python-programming"
    },
    {
      "url": "https://www.quora.com/topic/Python-programming-language-1"
    }
  ],
  "maxItems": 100,
  "maxAnswersPerQuestion": 100,
  "includeRelatedAnswers": false,
  "followQuestions": false,
  "includeComments": false,
  "maxCommentsPerAnswer": 20,
  "onlyNewOrChanged": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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 = {
    "startUrls": [
        {
            "url": "https://www.quora.com/How-do-I-learn-Python-programming"
        },
        {
            "url": "https://www.quora.com/topic/Python-programming-language-1"
        }
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("tortuga/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/How-do-I-learn-Python-programming" },
        { "url": "https://www.quora.com/topic/Python-programming-language-1" },
    ],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("tortuga/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/How-do-I-learn-Python-programming"
    },
    {
      "url": "https://www.quora.com/topic/Python-programming-language-1"
    }
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call tortuga/quora-scraper --silent --output-dataset

```

## MCP server setup

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