# Quora Scraper (`khadinakbar/quora-scraper`) Actor

Scrape Quora from a question, profile, space or topic URL, or a keyword, with the target type auto-detected. Export answer text, author, credentials, upvotes, views, dates, and question and profile metadata, with no cookies.

- **URL**: https://apify.com/khadinakbar/quora-scraper.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** Social media, MCP servers, Automation
- **Features:** Limited permissions
- **Stats:** 6 total users, 4 monthly users, 66.7% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 quora record scrapeds

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

### What is Quora Scraper?

Quora Scraper turns public Quora question, profile, space and topic URLs into a flat dataset of records. Answer rows return the answer text, author name and profile link, upvotes, views, created and updated dates, and the question each answer belongs to. Content marketers, SEO teams, market researchers and AI agents use it to see what real people ask and answer about a topic, with the target type detected from each URL and no Quora login or cookies.

### Why people use this Quora scraper

- **One input for every target.** Paste question, `/profile/`, `/q/` space or `/topic/` URLs into `startUrls`; the Actor detects each type.
- **Engagement on every answer.** `upvotes` and `views` let you rank answers and find the ones readers actually saw.
- **Plain text, ready to read.** Quora's rich text is flattened into `answerText`, so rows drop straight into spreadsheets and LLM prompts.
- **Answer context kept.** Each answer row carries `questionTitle` and `questionUrl`, plus `isMachineAnswer` to separate AI-generated answers from human ones.
- **Cost control per URL.** `maxItemsPerTarget` caps records for each target.

### Best fit for this Actor

- Best fit for audience research, FAQ and content planning, and building Q\&A corpora from public Quora pages.
- Designed for URL-driven work: start with the Quora pages you care about and collect their public answers and metadata.
- Quora groups closely related questions together, so answer rows can point to a sibling question through `questionUrl`. Group by `questionUrl` when you want strict per-question sets.
- For the same research on Reddit threads, continue with [Reddit Search Scraper](https://apify.com/khadinakbar/reddit-search-scraper) and compare both audiences side by side.

### Example workflow: from a question to a content brief

A content marketer at a coding bootcamp starts with three Quora question URLs about learning to program, with `maxItemsPerTarget` at 50. The dataset returns each answer's `answerText`, `upvotes`, `views` and `createdAt`. They sort answers by `views`, read the top ten, then tag recurring advice such as "build small projects" and "pick one language first". They export the table to a spreadsheet and feed the top answers into their brief as the questions the article must answer. A monthly schedule on the same URLs shows which new answers gain traction.

### Input

```json
{
  "startUrls": [
    "https://www.quora.com/What-is-the-best-way-to-learn-programming",
    "https://www.quora.com/topic/Computer-Programming"
  ],
  "maxItemsPerTarget": 50,
  "maxConcurrency": 5,
  "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"] }
}
```

| Field | Type | What it controls |
|---|---|---|
| `startUrls` | array of strings | Quora question, profile (`/profile/<name>`), space (`/q/<space>`) or topic (`/topic/<topic>`) URLs. Add at least one. |
| `maxItemsPerTarget` | integer | Records to collect per URL, from 1 to 1,000. Default 50. |
| `maxConcurrency` | integer | Parallel browsers, from 1 to 10. Default 5. |
| `proxyConfiguration` | object | Apify Proxy settings. Residential proxies give the smoothest access to Quora. |

### Output

Each row has a `type`: `question`, `answer`, `profile` or `space`. Fields appear when Quora shows them on the page.

| Field | What it contains |
|---|---|
| `type`, `url` | Record type and its Quora link |
| `questionTitle`, `questionUrl` | The question the record belongs to |
| `answerText` | Answer text as plain text |
| `upvotes`, `views` | Answer engagement |
| `createdAt`, `updatedAt` | When the answer was written and last edited |
| `authorName`, `authorProfileUrl`, `authorIsVerified` | Answer author |
| `isMachineAnswer` | `true` when Quora marks the answer as AI-generated |
| `name`, `bio`, `credential`, `profileImageUrl`, `isVerified`, `followerCount` | Profile fields on profile records |
| `answerCount`, `topics`, `askedAt`, `description` | Question and space metadata when the page shows it |
| `scrapedAt` | Collection time |

Example answer row (author details are illustrative):

```json
{
  "type": "answer",
  "url": "https://www.quora.com/What-is-the-best-way-to-learn-a-programming-language/answer/Jordan-Lee-12",
  "answerText": "Let's unfold the mystery. There are two ways to learn: reading alone, or building small projects while you read...",
  "upvotes": 16,
  "views": 3382,
  "createdAt": "2015-09-29T05:08:24.024Z",
  "updatedAt": "2015-09-29T10:32:27.214Z",
  "authorName": "Jordan Lee",
  "authorProfileUrl": "https://www.quora.com/profile/Jordan-Lee-12",
  "authorIsVerified": false,
  "isMachineAnswer": false,
  "questionTitle": "What is the best way to learn a programming language?",
  "questionUrl": "https://www.quora.com/What-is-the-best-way-to-learn-a-programming-language",
  "scrapedAt": "2026-10-01T01:31:36.961Z"
}
```

Each question URL also returns one `question` row with its `questionTitle`, `url` and `scrapedAt`.

### Pricing

This Actor uses Pay per event with Apify platform usage included in the event price. You pay one **Quora record scraped** event for each record saved and a memory-based **Actor Start** event at $0.005 per GB of allocated memory (minimum one unit). For example, one question URL with `maxItemsPerTarget` at 50 is up to 50 record events plus the memory-based startup event. Records beyond your per-target cap are never collected or charged. The live Pricing tab on this page shows the current event prices.

### API example

```bash
curl -X POST "https://api.apify.com/v2/acts/khadinakbar~quora-scraper/run-sync-get-dataset-items?token=YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"startUrls": ["https://www.quora.com/What-is-the-best-way-to-learn-programming"], "maxItemsPerTarget": 20}'
```

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")
run = client.actor("khadinakbar/quora-scraper").call(run_input={
    "startUrls": ["https://www.quora.com/What-is-the-best-way-to-learn-programming"],
    "maxItemsPerTarget": 20,
})
answers = [r for r in client.dataset(run["defaultDatasetId"]).iterate_items() if r["type"] == "answer"]
print(sorted(answers, key=lambda r: r.get("views") or 0, reverse=True)[:5])
```

### Use with AI agents (MCP)

Connect the Actor to Claude, ChatGPT or Cursor through [Apify MCP](https://mcp.apify.com) and ask:

> Collect up to 30 answers from this Quora question and summarize the three most-viewed pieces of advice, with links to each answer.

The agent passes the URL in `startUrls`, sets `maxItemsPerTarget` to 30, reads the dataset with `get-dataset-items`, keeps rows where `type` is `answer`, and cites each `url`. Each saved record is one event, so the per-target cap keeps the cost of the request predictable.

### Best results

| Starting situation | Helpful action | Expected outcome |
|---|---|---|
| A specific question | Paste its full Quora URL | The question row plus its public answers |
| A broad theme | Use a `/topic/` URL | Questions and answers under that topic |
| Smooth access | Select residential proxies in `proxyConfiguration` | Steady page loads |
| Ranking answers | Sort by `views`, then `upvotes` | The answers readers saw most |
| Human-only research | Filter `isMachineAnswer` to `false` | Answers written by people |

### Builder's note

I built this around URLs because Quora research usually starts from a page someone already found, and one auto-detecting input keeps that simple. I found that answers are far more useful with their reach attached, so every answer row keeps `views` and `upvotes` next to the flattened text.

### FAQ

#### Do I need a Quora account?

No. The Actor reads public Quora pages with no login or cookies.

#### Why does an answer show a different question URL?

Quora merges and groups similar questions, so an answer can belong to a sibling question. `questionUrl` always names the question the answer was written for.

#### How do I control cost?

Set `maxItemsPerTarget`; it caps the records per URL.

### Responsible use

This Actor collects publicly visible Quora content. Answers include author names and profile links, which are personal data under laws such as the GDPR and CCPA, so use them with a lawful basis and respect Quora's terms of service. Quora is a trademark of its owner; this independent Actor is not affiliated with or endorsed by Quora.

### Run outcomes

Read `OUTPUT` and `RUN_SUMMARY` together with the dataset. `COMPLETE` and `PARTIAL` count persisted useful records only. `VALID_EMPTY` means the upstream page answered successfully without matching records. `INVALID_INPUT` explains an unusable request. If required upstream requests fail and no useful records are saved, the run fails with `UPSTREAM_FAILED`. Startup billing still applies to empty and failed runs.

# Changelog

This Actor's version history is a separate document: https://apify.com/khadinakbar/quora-scraper/changelog.md

# Actor input Schema

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

List of Quora URLs to scrape. Each may be a question page (https://www.quora.com/What-is-the-best-way-to-learn-programming), a profile (https://www.quora.com/profile/Adam-DAngelo), a space (https://www.quora.com/q/<space>), or a topic (https://www.quora.com/topic/<topic>). The type is auto-detected from the URL. At least one URL is required.

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

Optional Quora search keywords. Each query becomes one https://www.quora.com/search URL. Use this or startUrls.

## `searchType` (type: `string`):

Optional Quora search type query parameter, such as question, answer, or post. Leave empty for Quora's default search.

## `timeFilter` (type: `string`):

Optional Quora search time query parameter, such as day, week, month, or year.

## `maxItemsPerTarget` (type: `integer`):

Maximum number of records to return for each URL or keyword. The Actor scrolls to paginate until this cap, then stops, so it doubles as your cost ceiling (each record is one billable event). Defaults to 50. Lower it for cheaper test runs.

## `maxConcurrency` (type: `integer`):

How many target pages to scrape in parallel. Higher is faster but uses more proxy IPs and memory; lower is gentler on anti-bot defenses. Defaults to 5 (max 10). Leave default unless you hit blocking.

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

Proxy settings. Residential proxies are strongly recommended — Quora is protected by Cloudflare and datacenter IPs are often challenged. Defaults to Apify Proxy automatic. Override to select residential proxies or a specific country for reliable access.

## Actor input object example

```json
{
  "startUrls": [
    "https://www.quora.com/What-is-the-best-way-to-learn-programming"
  ],
  "maxItemsPerTarget": 20,
  "maxConcurrency": 5,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `dataset` (type: `string`):

All Quora records collected this run — answers, questions, profiles, spaces, and search results. Download as JSON, CSV, Excel, HTML, or RSS.

# 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": [
        "https://www.quora.com/What-is-the-best-way-to-learn-programming"
    ],
    "maxItemsPerTarget": 20
};

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

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

```

## MCP server setup

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