# Quora Answers Scraper (`superslowsloth/quora-answers`) Actor

Scrape every answer on a Quora question - text, author, credential, upvotes, comments and date - one flat row per answer.

- **URL**: https://apify.com/superslowsloth/quora-answers.md
- **Developed by:** [Superslow Sloth](https://apify.com/superslowsloth) (community)
- **Categories:** Social media, AI, News
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.69 / 1,000 answer 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?

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 Answers Scraper

Give it one or more [Quora](https://www.quora.com) question URLs and get one
flat row per answer: the full answer text, who wrote it, the credential Quora
prints under their name, upvotes, comments, views and the date it was written.

No account, no cookies, no login.

### What one row contains

| Field | Notes |
|---|---|
| `answer_id` | Quora's own numeric answer id, as a string. It is an identifier, not a quantity - kept as text so a spreadsheet cannot round it. |
| `question_url` | Verbatim the URL you asked for, on every row, so rows from a multi-question run group on it. |
| `question_title` | Quora's title for the question that URL **resolves to**. Quora merges duplicate questions, so an older slug can come back under a newer title - that is Quora's answer, not a mismatch. |
| `answer_text` | Plain text. Quora stores prose as a structured document; paragraphs and list items become lines, embedded images contribute nothing rather than a blank line. |
| `answer_url` | Permalink to this answer. For a mixed-in answer (see below) this points at the question it was actually written under. |
| `is_direct_answer` | False when Quora served this as a *relevant answer* written under a different question. Read this before treating a row as an answer to your question. |
| `author_name` | Null on anonymous answers. |
| `author_credential` | Quora's one-line credential - "Aerospace Engineer at British Aircraft Corporation (2014-present)". Null when the author never wrote one. |
| `author_url` | Profile link, null for anonymous. |
| `upvote_count`, `comment_count`, `view_count` | Integers, or **null** where Quora did not report them. |
| `answer_date` | ISO 8601 UTC. |

#### Why the counts are null and not zero

Quora omits the field entirely on some answers rather than sending a zero. A
fabricated `0` would read as a measurement - an answer nobody upvoted - and
someone would rank on it. `null` says "Quora did not tell us", which is the
truth.

### Relevant answers

A Quora question page is not a pure list of answers to that question. Quora
mixes in strong answers written under closely related questions, because to a
reader they answer the same thing. Those rows are real answers with real
authors, but they are not answers to the exact question you asked for.

Two ways to handle it:

- Leave **Answer ranking** on the default and filter on `is_direct_answer`
  afterwards. You get both sets and can decide later.
- Set **Answer ranking** to *Only this question's answers*, which sends
  Quora's own `hide_relevant_answers` ordering. Measured 2026-08-25: it shifts
  the mix but does not empty it - a run with it on still returned some rows
  with `is_direct_answer: false`. It is a hint to Quora's ranker, not a filter,
  so `is_direct_answer` is still the field to trust.

### How it fetches

Quora renders a question page from an embedded Relay payload and refills it
from `/graphql/gql_para_POST`, its own persisted-query endpoint. This actor
uses that endpoint rather than scraping rendered HTML: it loads the question
page once for the CSRF `formkey` and the numeric question id, then pages the
answer list as JSON. Nothing is parsed out of markup, so a cosmetic redesign
does not break it.

The connection behind that endpoint is a *page list*, not an answer list - ad
slots, section headers and related-question blocks arrive on it as siblings of
the answers. Those are dropped, never counted and never charged for.

Quora reads the TLS handshake, not the `User-Agent`. Plain HTTP clients get
HTTP 403; a real Chrome fingerprint (`curl_cffi`) got HTTP 200 on every request
during testing on 2026-08-25.

Residential proxy is the default and no country is pinned. A datacenter address
gets a login wall served with HTTP 200 - a refusal wearing a success code - and
this actor treats a page with no `formkey` in it as exactly that: it rotates to
a new exit address and retries, rather than reporting a question with thousands
of answers as empty.

### What this actor does not do

**There is no search-term input.** Quora's own search is behind a hard login
wall for logged-out visitors: `quora.com/search?q=...` redirects to a sign-in
page and its search query returns `null`, measured 2026-08-25. Rather than ship
a field that silently returns nothing, this actor takes question URLs only.

### Pricing

Pay per event. A small actor-start fee, then one charge per answer row. A run
that legitimately finds nothing still costs only the start fee.

# Actor input Schema

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

One or more Quora question pages, for example https://www.quora.com/Why-is-the-sky-blue. An answer permalink works too - the question it belongs to is scraped. Localised hosts such as jp.quora.com are accepted and rewritten to www.quora.com. Quora's own search is behind a login wall, so a search term cannot be used here: paste the question URLs instead.

## `maxAnswers` (type: `integer`):

Stop after this many answers for each question. Quora returns roughly eight answers per request, so 50 answers costs about seven requests.

## `ranking` (type: `string`):

Quora's own ordering toggle. Default is the order Quora shows a reader, which mixes in highly rated answers written under closely related questions. "Only this question's answers" sends Quora's hide\_relevant\_answers ranking, which asks it to push those down - measured 2026-08-25 it shifts the mix rather than emptying it, so it is a hint to Quora's ranker, not a filter. Every row carries is\_direct\_answer either way, and that is the field to filter on.

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

Residential is the default and is what this actor was measured on. Quora serves datacenter addresses a login wall with an HTTP 200, which produces a run with no rows rather than an error. No country is pinned: pinning one narrows the exit pool, and Quora answered addresses in several countries during testing on 2026-08-25.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.quora.com/Why-is-the-sky-blue"
    }
  ],
  "maxAnswers": 50,
  "ranking": "default",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `answers` (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/Why-is-the-sky-blue"
        }
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("superslowsloth/quora-answers").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/Why-is-the-sky-blue" }],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("superslowsloth/quora-answers").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/Why-is-the-sky-blue"
    }
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call superslowsloth/quora-answers --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,superslowsloth/quora-answers"
        }
    }
}

```

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/AZIFCJ756cjfuq86v/builds/JhZP9elJNNe94lC1L/openapi.json