# Quora Scraper With Human Answer Quality Score (`simpleapi/quora-scraper`) Actor

🚀 Quora Scraper extracts Questions, Answers, Profiles, Topics & Spaces from Quora. 📥 Perfect for research, lead gen, content insights & competitor analysis. ⚙️ Fast, structured data for smarter decisions.

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

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

### Quora Scraper — Human Answer Quality Score

Quora Scraper With Human Answer Quality Score turns a Quora keyword search or a batch of direct URLs into questions, answers, profiles, topics, and spaces — with every answer scored by a transparent, reproducible quality formula and filtered by whether it came from a human or Quora's own AI-bot answer feature. It's built for content researchers who want genuine expert answers rather than AI-generated filler, community and moderation teams auditing answer quality at scale, and market researchers mining Quora's Q\&A data for real customer language and pain points. No Quora login is required. Every section below documents an input, an output field, or exactly how the quality score and AI filter are computed.

### What is Quora Scraper With Human Answer Quality Score?

This Actor scrapes Quora's public pages — questions with their full answer thread, profiles, topics, and spaces — using browser-impersonated HTTP requests with a headless-browser fallback for Cloudflare-protected pages, and adds two things a plain Quora scraper doesn't: a deterministic quality score for every answer, and a filter for excluding (or isolating) Quora's AI-generated answers.

Key capabilities, read from the source:

- **A fully transparent, reproducible quality score.** `compute_quality_score()` in `src/main.py` blends three signals already present on the answer payload — upvotes (log-scaled, weight 0.5), answer length (weight 0.3), and freshness/recency (weight 0.2) — into a 0-100 `qualityScore`. No extra fetch is needed, and the same inputs always produce the same score.
- **AI-vs-human answer filtering.** `filterAiAnswers` reads Quora's own `isMachineAnswer` flag to `include` everything, `exclude` AI-bot answers (the default), or keep `only` AI answers for studying bot content specifically — filtered-out answers are dropped before charging, not charged then discarded.
- **Real absolute timestamps, not just relative strings.** `absolute_time()` derives an exact UTC ISO-8601 `answer_created_at` from the same `creationTime` microsecond field that also produces the relative `answer_timestamp` ("3y") string — both are included.
- **Cloudflare-aware GraphQL pagination.** Answer pagination calls Quora's internal GraphQL endpoint, which is Cloudflare-protected; a curl-based POST that gets a "Just a moment" challenge automatically switches to running the same GraphQL call from inside a real headless browser page, which inherits the browser's already-solved `cf_clearance` cookie.
- **Sticky per-target residential IPs.** Each scraped URL keeps one sticky proxy exit IP across all of its requests (page load plus answer pagination), since Quora's cookies and form keys tied to a session become invalid if the exit IP changes mid-target.
- **Optional LLM enrichment, off by default.** `aiEnhancement` adds model-graded sentiment and topic keywords per kept answer when an API key is supplied — the deterministic `qualityScore` always runs regardless, and an enrichment failure leaves the AI fields `null` rather than blocking the row.

### What data can I extract with Quora Scraper With Human Answer Quality Score?

Every field below is read directly from `build_answer_row()` and the `scrape_question`/`scrape_profile`/`scrape_topic`/`scrape_space` functions in `src/main.py` — dedicated dataset views (`quality`, `overview`, `questions`, `answers`, `profiles`, `topics`, `spaces`) group these by content type.

#### Answer fields

| Field | Example Value | Notes |
| --- | --- | --- |
| `answer_text` / `answer_url` | full answer body / link | |
| `author_name` / `author_url` / `author_credentials` | answerer identity + stated credentials | |
| `upvotes` / `comments_count` / `shares_count` | `342` / `18` / `12` | |
| `answer_timestamp` | `"3y"` | Quora's own relative-age string |
| `answer_created_at` | `2023-07-15T12:51:39+00:00` | Real absolute ISO timestamp, derived from the same source field |
| `is_ai_answer` | `false` | Quora's own `isMachineAnswer` flag |
| `qualityScore` | `78.4` | Deterministic 0-100 blend of upvotes/length/freshness — reproducible from the row alone |
| `aiSentiment` / `aiTopics` | `"positive"` / `["career advice", "salary"]` | `null` unless `aiEnhancement` is on and succeeds |

#### Question, profile, topic, and space fields

| Field | Example Value | Content Type |
| --- | --- | --- |
| `title` / `answer_count` / `follow_count` / `topics` | question text, counts, topic tags | `question` |
| `name` / `bio` / `credentials` / `follower_count` / `following_count` / `answer_count` / `question_count` / `total_views` | profile fields | `profile` |
| `name` / `description` / `follower_count` / `question_count` | topic fields | `topic` |
| `name` / `description` / `follower_count` / `post_count` / `contributor_count` | space fields | `space` |

### Why not build this yourself?

Quora has no public API — every field here comes from reverse-engineered embedded GraphQL payloads (`window.push()` blobs) in the page HTML, and the internal endpoint used for answer pagination is Cloudflare-protected in a way that specifically blocks a plain HTTP client even from an IP whose page-load request just succeeded. Getting past that requires running a real headless browser to solve the Cloudflare challenge once, then replaying the GraphQL call *from inside that browser context* so it inherits the solved cookie — a two-engine fallback this Actor already implements. On top of that, a "blocked" Quora response is often a technically-valid 200 page that just lacks the real content blob (a throttle shell), so naive scrapers can silently collect empty data — this Actor validates that real, rich fields are actually present before accepting a page as successfully fetched.

### How to use data extracted from Quora Scraper With Human Answer Quality Score?

#### Content and SEO research

Search a topic keyword with `filterAiAnswers: "exclude"` and sort by `qualityScore` to surface the most substantive human answers on a topic — useful groundwork for content briefs grounded in real audience language.

#### Community and moderation auditing

Set `filterAiAnswers: "only"` to isolate Quora's own AI-bot answers specifically, useful for auditing how much of a topic's Q\&A content is bot-generated versus human-authored.

#### Market and customer research

Scrape questions and answers around your product category, using `minUpvotes` and `minAnswerLength` to filter down to substantive, community-endorsed answers before analyzing them for customer pain points and language patterns.

#### AI agents and content pipelines

Because `qualityScore` is deterministic and reproducible from the row itself, an agent can re-derive or verify the ranking without needing to re-fetch anything — and can branch on `is_ai_answer` before deciding whether to trust an answer as a human opinion.

### 🔼 Input sample

| Parameter | Required | Type | Description | Example Value |
| --- | --- | --- | --- | --- |
| `searchQueries` | No | array | Keywords to search on Quora; each resolves to relevant URLs automatically. | `["python programming"]` |
| `directUrls` | No | array | Direct Quora URLs — questions, `/profile/`, `/topic/`, or `/q/` (space) pages. | `["https://www.quora.com/What-is-Python-primarily-used-for"]` |
| `maxResults` | No | integer (1–50000) | Max results per search keyword, and max answers pulled per question. Default `50`. | `20` |
| `filterAiAnswers` | No | string enum | `include`, `exclude` (human-only, default), or `only` (AI-only). | `"exclude"` |
| `minUpvotes` | No | integer | Drop answers under this upvote count. `0` = no threshold. Default `0`. | `10` |
| `minAnswerLength` | No | integer | Drop answers shorter than this many characters. `0` = no gate. Default `0`. | `200` |
| `scrapeAnswers` | No | boolean | `true`: full answer extraction. `false`: question metadata only, fast and cheap. Default `true`. | `true` |
| `aiEnhancement` | No | boolean | Add LLM-graded sentiment/topics per kept answer. Requires an API key. Default `false`. | `false` |
| `aiModel` | No | string enum | Model/provider for enrichment (Claude, GPT, Gemini, Grok, DeepSeek, Sonar, Mistral variants). Default `"claude-haiku-4-5"`. | `"claude-haiku-4-5"` |
| `aiApiKey` | No | string (secret) | Provider API key; falls back to the matching environment variable if empty. | `"sk-..."` |
| `proxyConfiguration` | No | object | Starts direct, escalates to datacenter then residential automatically on a block. | `{"useApifyProxy": true}` |

```json
{
  "searchQueries": ["machine learning careers"],
  "maxResults": 20,
  "filterAiAnswers": "exclude",
  "minUpvotes": 10
}
```

**Common pitfall:** each emitted row is charged twice in this Actor's own billing flow — once via `Actor.push_data(item, charged_event_name="row_result")` and again via a separate `Actor.charge(event_name="result-item", count=1)` call in `sink()`. Check your run's cost breakdown for both `row_result` and `result-item` events rather than assuming a single charge per row.

### 🔽 Output sample

Output is one JSON row per question, answer, profile, topic, or space, pushed to the run's default dataset.

```json
{
  "content_type": "answer",
  "title": "What is Python primarily used for?",
  "answer_text": "Python is widely used for web development, data science, automation...",
  "answer_url": "https://www.quora.com/What-is-Python-primarily-used-for/answer/...",
  "author_name": "Jane Doe",
  "author_credentials": "Software Engineer, 10+ years",
  "upvotes": 342,
  "comments_count": 18,
  "shares_count": 12,
  "answer_timestamp": "3y",
  "answer_created_at": "2023-07-15T12:51:39+00:00",
  "is_ai_answer": false,
  "qualityScore": 78.4,
  "aiSentiment": null,
  "aiTopics": null,
  "question_title": "What is Python primarily used for?",
  "scrape_timestamp": "2026-07-26T09:00:00+00:00"
}
```

### How do you filter and target specific answers?

**AI-vs-human is the primary quality lever.** `filterAiAnswers: "exclude"` (the default) is the right setting for genuine expert-opinion research; switch to `"only"` specifically when you're studying Quora's bot-answer behavior rather than trying to avoid it.

**Combine upvotes and length for substance, not just popularity.** `minUpvotes` alone can still surface short, low-effort answers that happen to be old and highly-upvoted; pairing it with `minAnswerLength` filters for answers that are both community-endorsed and substantive.

**Turn off answer scraping for structure-only runs.** `scrapeAnswers: false` returns just question metadata (title, answer count, follower count, topics) — much faster and cheaper when you only need to map a topic's question landscape before deciding which questions deserve a full answer scrape.

Three real examples:

```json
{ "searchQueries": ["career advice"], "filterAiAnswers": "exclude", "minUpvotes": 20, "minAnswerLength": 300 }
```

High-bar human-answer research: substantive, community-endorsed, non-bot.

```json
{ "directUrls": ["https://www.quora.com/some-question"], "filterAiAnswers": "only" }
```

Isolate Quora's AI-bot answers on a specific question for bot-content auditing.

```json
{ "searchQueries": ["startup funding"], "scrapeAnswers": false, "maxResults": 100 }
```

Fast, cheap question-landscape mapping without full answer text.

### ▶️ Want to try other scrapers?

| Scraper | What it extracts |
| --- | --- |
| Quora Search Scraper — Fresh Trending Question Monitor | Newly-trending Quora questions |
| Reddit Posts Scraper with Author Media Details | Post threads with author and media data |
| Ahrefs Scraper — Competitor Comparison | Backlink and keyword competitor comparison |
| Google Search Autocomplete API | Keyword suggestion expansion |

### How to extract Quora data programmatically

This Actor runs as a standard Apify Actor call — one API call in, structured JSON dataset out, using your Apify API token.

#### Python example

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_API_TOKEN>")
run = client.actor("<YOUR_USERNAME>/quora-scraper-with-human-answer-quality-score").call(run_input={
    "searchQueries": ["machine learning careers"],
    "filterAiAnswers": "exclude",
    "minUpvotes": 10,
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    if item.get("content_type") == "answer":
        print(item["author_name"], item["qualityScore"], item["upvotes"])
```

#### Export to spreadsheets or CRM

Every dataset supports one-click CSV/Excel export from the Apify Console, plus dedicated dataset views (`quality`, `questions`, `answers`, `profiles`, `topics`, `spaces`) for exporting one content type at a time.

### Is it legal to scrape Quora?

Scraping publicly visible Quora questions, answers, and profiles is generally lawful, since this data is published for anyone to view without logging in — the underlying legal question was tested directly in *hiQ Labs v. LinkedIn* (9th Cir.), which held that scraping public, non-password-protected data does not violate the U.S. Computer Fraud and Abuse Act. Author names and profile bios can constitute personal data under GDPR/CCPA when tied to an identifiable individual, so treat that subset accordingly if you store or reuse it at scale, and consult legal counsel for commercial applications.

### ❓ FAQ

#### Is the quality score a Quora metric or something this Actor computes?

It's computed entirely by this Actor — Quora doesn't publish a quality score. `compute_quality_score()` blends upvotes, answer length, and freshness into a reproducible 0-100 number using fields already present on the answer payload, documented with exact weights (0.5/0.3/0.2) in the source.

#### How does the Actor tell a human answer from an AI one?

It reads Quora's own `isMachineAnswer` flag on the answer payload — this Actor doesn't guess or infer it from the text itself.

#### Do I need an AI API key to use this Actor?

No — the deterministic `qualityScore` always runs with zero extra cost or configuration. An API key is only needed if you turn on `aiEnhancement` for optional LLM-graded sentiment and topic tags.

#### Why would an answer get dropped even though it matched my search?

`filterAiAnswers`, `minUpvotes`, and `minAnswerLength` are all post-filters applied to the answer stream — an answer that doesn't clear your thresholds is dropped before it's charged, so a lower "kept" count than expected usually means your filters are working as intended, not that the scrape failed.

#### Am I charged once or twice per row?

Per the source, each pushed row triggers two separate charging calls: `Actor.push_data(..., charged_event_name="row_result")` and a follow-up `Actor.charge(event_name="result-item", count=1)`. Check both event types in your run's cost breakdown.

#### What happens if Quora's GraphQL endpoint blocks the request?

The Actor detects a Cloudflare challenge response and automatically switches to running the same GraphQL query from inside a real headless browser page, which already carries the solved Cloudflare cookie — this happens transparently mid-run.

#### How does this compare to other Quora scrapers?

As observed on the Apify Store on 2026-07-26, `memo23/Quora-Scraper-with-optional-login` and `botflowtech/quora-scraper-pro` both scrape Quora content but neither documents a deterministic answer-quality score or an AI-vs-human answer filter — those are specific to this Actor.

#### Does this work with AI agent frameworks?

Yes — call it as a standard HTTP endpoint via the Apify API from any agent framework capable of making an API call; there's no MCP-specific integration for this Actor.

### Conclusion

Quora Scraper With Human Answer Quality Score turns a Quora search into structured, quality-ranked Q\&A data — a transparent scoring formula, a real AI-vs-human filter, and optional LLM enrichment layered on top. It fits content research, community auditing, and market research that needs genuine, substantive answers rather than unfiltered noise. Start a run from the Apify Console or the Apify API with your target keywords or URLs to get your first quality-scored export.

# Actor input Schema

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

Keywords to search on Quora. Each keyword is resolved to relevant Quora URLs and scraped automatically. Leave empty to only use direct URLs. Example: \["machine learning careers"].

## `directUrls` (type: `array`):

Paste Quora URLs to scrape in bulk — questions, profiles (/profile/...), topics (/topic/...) or spaces (/q/...). Example: https://www.quora.com/What-is-Python-primarily-used-for

## `maxResults` (type: `integer`):

Max results per search keyword, and max answers pulled from each question's answer stream (quality filters below are applied to that stream). Default 50.

## `filterAiAnswers` (type: `string`):

How to treat Quora's AI-generated bot answers (is\_ai\_answer). include = keep everything. exclude = human authors only (drop AI). only = keep just the AI answers, for studying bot content. Default exclude.

## `minUpvotes` (type: `integer`):

Only keep answers with at least this many upvotes — community endorsement as a quality gate. Example: minUpvotes=10 drops every answer under 10 upvotes. 0 = no threshold. Default 0.

## `minAnswerLength` (type: `integer`):

Drop thin/low-effort answers shorter than this many characters of body text. Example: minAnswerLength=200 keeps only substantive answers. 0 = no length gate. Default 0.

## `scrapeAnswers` (type: `boolean`):

✅ On: extract full answer text with author, upvotes and the quality filters/score above. ⬜ Off: question metadata only — fast, cheap, structure-only runs. Default on.

## `aiEnhancement` (type: `boolean`):

OFF by default. When on AND an API key is supplied, each kept answer also gets model-graded sentiment (positive/negative/neutral/mixed) and up to 3 topic keywords. The deterministic qualityScore always runs regardless. On any failure the AI fields stay null.

## `aiModel` (type: `string`):

Provider auto-detected from the name: claude-*=Anthropic, gpt-*/o1/o3=OpenAI, gemini-*=Google, grok-*=xAI, deepseek-*=DeepSeek, sonar*=Perplexity, mistral-\*=Mistral. Cheaper mini/flash/haiku/lite models are recommended for classification.

## `aiApiKey` (type: `string`):

Provider API key for AI enrichment. Kept secret. Falls back to the provider env var if empty (ANTHROPIC\_API\_KEY / OPENAI\_API\_KEY / GEMINI\_API\_KEY / XAI\_API\_KEY / DEEPSEEK\_API\_KEY / PERPLEXITY\_API\_KEY / MISTRAL\_API\_KEY).

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

Proxy settings. The scraper starts DIRECT (no proxy) and only escalates to datacenter, then residential, if Quora blocks the request — sticking with residential afterwards.

## Actor input object example

```json
{
  "searchQueries": [
    "python programming"
  ],
  "directUrls": [
    "https://www.quora.com/What-is-Python-primarily-used-for"
  ],
  "maxResults": 10,
  "filterAiAnswers": "exclude",
  "minUpvotes": 5,
  "minAnswerLength": 0,
  "scrapeAnswers": true,
  "aiEnhancement": false,
  "aiModel": "claude-haiku-4-5",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# 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": [
        "python programming"
    ],
    "directUrls": [
        "https://www.quora.com/What-is-Python-primarily-used-for"
    ],
    "maxResults": 10,
    "minUpvotes": 5,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("simpleapi/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": ["python programming"],
    "directUrls": ["https://www.quora.com/What-is-Python-primarily-used-for"],
    "maxResults": 10,
    "minUpvotes": 5,
    "proxyConfiguration": { "useApifyProxy": True },
}

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

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).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": [
    "python programming"
  ],
  "directUrls": [
    "https://www.quora.com/What-is-Python-primarily-used-for"
  ],
  "maxResults": 10,
  "minUpvotes": 5,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call simpleapi/quora-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=simpleapi/quora-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/YdEAHlENbN2zrzZjV/builds/tbswVaHDWclcd3UeD/openapi.json