# Quora Scraper 💬 Questions & Answers — Only $5/1K Answers 💰 (`viralanalyzer/quora-scraper`) Actor

Extract Quora questions and answers by search keyword — question title, URL, topic, upvotes, followers, and full answer bodies. No API key needed.

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

## Pricing

from $5.00 / 1,000 item processeds

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?

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

**$5/1K Answers 💰** — [View on Apify Store](https://apify.com/viralanalyzer/quora-scraper)

Scrape questions and answers from Quora: question title, topic, answer count, followers — plus full answers with author, author bio, upvotes and publish date.

> **Works from direct question URLs only.** Quora's `/search` route redirects anonymous sessions to the sign-in page — measured over a residential IP and through a real browser, both land on "Continue with Google". Search keywords therefore cannot work without an account, and this Actor will not pretend otherwise. Pass question URLs in `urls`.

Quora is one of the most anti-bot platforms (Cloudflare + login walls + lazy loading). This actor was built to survive it: Apify **RESIDENTIAL proxy** by default, cookie seeding, stealth init script and lazy-load scrolling.

***

### 🚀 How it works

1. Give it **question URLs** (`urls`).
2. `searchQueries` is still accepted for backward compatibility, but Quora gates `/search` behind a login — those runs end with a diagnostic record and are **not charged**.
3. For each question it loads the page (cookie-seeded residential session), scrolls to trigger lazy loading, expands answers (optional), and extracts:

```json
{
  "url": "https://www.quora.com/What-is-the-best-way-to-learn-programming",
  "question": "What is the best way to learn programming?",
  "topic": "Programming",
  "upvotes": 1200,
  "answers_count": 350,
  "followers": 9800,
  "answers": [
    {
      "author": "Jane Doe",
      "author_bio": "Software Engineer at X",
      "content": "The best way is to build things...",
      "upvotes": 452,
      "is_expanded": true,
      "published_at": "3y"
    }
  ],
  "scrapedAt": "2026-08-13T02:55:00.000Z"
}
```

> Missing fields are returned as `null` — honest data, never invented. Fields that Quora does not show (e.g. followers on some pages) stay `null`.

***

### ⚙️ Input

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `urls` | stringList | — | Quora question URLs to scrape |
| `searchQueries` | stringList | — | **Not working**: Quora redirects `/search` to the sign-in page for anonymous sessions. Accepted so old task configurations do not break; produces a diagnostic, never a charge. |
| `maxQuestionsPerSearch` | integer | 5 | Max question links extracted per search query (1–20) |
| `maxAnswersPerQuestion` | integer | 5 | Max answers extracted per question (1–20). Values above 4 use Quora's own paginated query — see note below |
| `expandAnswers` | boolean | false | Click "Continue reading" so long answers are extracted in full |
| `proxyConfig` | proxy | RESIDENTIAL | Quora blocks datacenter IPs — keep RESIDENTIAL |

**`urls` is required in practice** — `searchQueries` alone cannot return data (see above).

**About `maxAnswersPerQuestion` above 4** — the Quora question page itself only carries **4 answers**
(measured across 6 fetches of 3 different questions). Everything past that is fetched with Quora's own
paginated GraphQL query, which requires a real browser session (it sends a `Quora-Formkey` header plus
session cookies). Measured with that route: **20 answers per question on 4 different questions**.
When the remote-browser endpoint is not configured, the run delivers the 4 answers the page carries and
says so in the log — it never pads the output to look like it delivered more.

***

### 📦 Output

Each dataset item is one question with its answers nested. Field reference:

| Field | Type | Notes |
|-------|------|-------|
| `url` | string | Question page URL (always present) |
| `question` | string | Question title (always present) |
| `topic` | string | null | Primary topic |
| `upvotes` | integer | null | Question upvotes. **Always `null`**: the page payload carries no upvote count for the question itself (checked across 48 data blobs). Answer upvotes below are real. |
| `answers_count` | integer | null | Answers count shown on page |
| `followers` | integer | null | Question followers |
| `answers[]` | array | See below |
| `answers[].author` | string | null | Author name |
| `answers[].author_bio` | string | null | Author credential/bio line |
| `answers[].content` | string | null | Answer text |
| `answers[].upvotes` | integer | null | Answer upvotes |
| `answers[].is_expanded` | boolean | `true` = full text loaded |
| `answers[].published_at` | string | null | Date as displayed on Quora (e.g. "3y", "2 weeks ago") |
| `scrapedAt` | string | ISO timestamp |

***

### 💰 Pricing & free tier

- **$5 per 1K answers** extracted (PPE: `answer-scraped`). Questions themselves cost nothing.
- Quora serves, on the same question page, answers written under equivalent or merged questions — and presents them as answers to that question. They are delivered and billed like any other answer, and each one carries `is_equivalent_answer: true` plus `source_question_url` so you can tell exactly which question it came from.
- **Free tier**: limited to **1 question** and **2 answers** per run (so you can try the actor for free). Upgrade your Apify plan to unlock full limits.
- Diagnostic runs (login wall / Cloudflare challenge / zero results) are **not charged**.

***

### 🛡️ Anti-bot notes (honest limitations)

- Quora aggressively blocks datacenter IPs. **Always run with Apify RESIDENTIAL proxy** (the default).
- If a run returns a **diagnostic item** with `setup_status: "DIAGNOSTIC_GUIDE"`, the IP was blocked or the page hit a login wall. Wait ~30 minutes and retry.
- If `expandAnswers: false`, long answers may be **truncated** by Quora (extracted text stops at "Continue reading"). Enable `expandAnswers` for full content.
- `published_at` is captured **as Quora displays it** (relative like "3y" or "2 weeks ago") — Quora does not expose exact timestamps in the public DOM.
- Answers are read from the page's own data payload, not from CSS classes, so obfuscated class names do not affect it.
- **A question page carries only its first batch of answers** — measured 4 per page across 6 fetches of 3 different questions. Asking for more returns what the page has; the rest needs Quora's paginated API, which is not implemented.
- **Quora mixes in answers written under equivalent/merged questions.** Measured: 8 of 12 answers came from a related question rather than the one requested. Every answer carries `is_equivalent_answer` and `source_question_url` so you can tell them apart — and **you are only charged for answers belonging to the question you asked for**.

***

### 🔍 Use cases

- Content research / SEO: find the most-upvoted answers on a topic
- Competitor analysis: what questions your audience asks
- Building a Q\&A knowledge base for RAG / training data
- Influencer discovery: top answer authors on a topic (via `author` + `author_bio`)

***

*Scrape responsibly. Respect Quora's Terms of Service and rate limits. This actor is not affiliated with Quora.*

***

## 💬 Quora Scraper — Perguntas & Respostas

**$5/1K Respostas 💰** — [Veja na Apify Store](https://apify.com/viralanalyzer/quora-scraper)

Extraia perguntas e respostas do Quora: título da pergunta, tópico, upvotes, número de respostas, seguidores — e as respostas completas com autor, bio do autor, upvotes e data de publicação. Funciona com **URLs diretas de perguntas** ou **palavras-chave de busca**.

O Quora é uma das plataformas mais anti-bot (Cloudflare + login walls + lazy loading). Este actor foi construído para sobreviver: proxy **RESIDENTIAL** da Apify por padrão, cookie seeding, script de stealth e scroll para lazy loading.

***

### 🚀 Como funciona

1. Informe **URLs de perguntas** (`urls`). O campo `searchQueries` continua aceito por compatibilidade, mas o Quora exige login na busca: esses runs terminam com diagnóstico e **não são cobrados**.
2. Para palavras-chave, o actor visita `https://www.quora.com/search?q=...` e descobre os links de perguntas automaticamente.
3. Para cada pergunta, carrega a página (sessão residencial com cookie seed), rola para ativar o lazy loading, expande respostas (opcional) e extrai:

```json
{
  "url": "https://www.quora.com/What-is-the-best-way-to-learn-programming",
  "question": "What is the best way to learn programming?",
  "topic": "Programming",
  "upvotes": 1200,
  "answers_count": 350,
  "followers": 9800,
  "answers": [
    {
      "author": "Jane Doe",
      "author_bio": "Software Engineer at X",
      "content": "The best way is to build things...",
      "upvotes": 452,
      "is_expanded": true,
      "published_at": "3y"
    }
  ],
  "scrapedAt": "2026-08-13T02:55:00.000Z"
}
```

> Campos ausentes retornam `null` — dados honestos, nunca inventados. Campos que o Quora não exibe (ex.: seguidores em algumas páginas) permanecem `null`.

***

### ⚙️ Input

| Campo | Tipo | Padrão | Descrição |
|-------|------|--------|-----------|
| `urls` | stringList | — | URLs de perguntas do Quora para extrair |
| `searchQueries` | stringList | — | **Não funciona**: o Quora redireciona `/search` para a página de login em sessão anônima. Continua aceito para não quebrar configurações antigas; gera diagnóstico, nunca cobrança. |
| `maxQuestionsPerSearch` | integer | 5 | Máx. de links de perguntas por busca (1–20) |
| `maxAnswersPerQuestion` | integer | 5 | Máx. de respostas por pergunta (1–20). Acima de 4 usa a query paginada do próprio Quora — veja a nota abaixo |
| `expandAnswers` | boolean | false | Clica em "Continue reading" para respostas longas completas |
| `proxyConfig` | proxy | RESIDENTIAL | O Quora bloqueia IPs de datacenter — mantenha RESIDENTIAL |

**Na prática, `urls` é obrigatório** — `searchQueries` sozinho não devolve dado (veja acima).

**Sobre `maxAnswersPerQuestion` acima de 4** — a página de pergunta do Quora carrega apenas **4 respostas**
(medido em 6 leituras de 3 perguntas distintas). O que passa disso vem da query paginada do próprio Quora,
que exige sessão real de navegador (manda o cabeçalho `Quora-Formkey` mais os cookies da sessão). Medido
por essa rota: **20 respostas por pergunta em 4 perguntas distintas**. Sem o endpoint de navegador remoto
configurado, o run entrega as 4 respostas que a página traz e registra isso no log — nunca infla a saída
para parecer que entregou mais.

***

### 📦 Output

Cada item do dataset é uma pergunta com suas respostas aninhadas. Referência:

| Campo | Tipo | Notas |
|-------|------|-------|
| `url` | string | URL da pergunta (sempre presente) |
| `question` | string | Título da pergunta (sempre presente) |
| `topic` | string | null | Tópico principal |
| `upvotes` | integer | null | Upvotes da pergunta |
| `answers_count` | integer | null | Nº de respostas exibido na página |
| `followers` | integer | null | Seguidores da pergunta |
| `answers[]` | array | Ver abaixo |
| `answers[].author` | string | null | Nome do autor |
| `answers[].author_bio` | string | null | Bio/credencial do autor |
| `answers[].content` | string | null | Texto da resposta |
| `answers[].upvotes` | integer | null | Upvotes da resposta |
| `answers[].is_expanded` | boolean | `true` = texto completo carregado |
| `answers[].published_at` | string | null | Data como exibida no Quora (ex.: "3y", "2 weeks ago") |
| `scrapedAt` | string | Timestamp ISO |

***

### 💰 Preço & free tier

- **$5 por 1K respostas** extraídas (PPE: `answer-scraped`). Perguntas não custam nada.
- O Quora serve, na mesma página da pergunta, respostas escritas sob perguntas equivalentes ou mescladas — e as apresenta como respostas daquela pergunta. Elas são entregues e cobradas como qualquer outra, e cada uma traz `is_equivalent_answer: true` e `source_question_url` para você saber exatamente de onde veio.
- **Free tier**: limitado a **1 pergunta** e **2 respostas** por execução (teste grátis). Faça upgrade do plano Apify para liberar os limites completos.
- Execuções de diagnóstico (login wall / Cloudflare / zero resultados) **não são cobradas**.

***

### 🛡️ Notas anti-bot (limitações honestas)

- O Quora bloqueia agressivamente IPs de datacenter. **Sempre execute com proxy RESIDENTIAL da Apify** (padrão).
- Se uma execução retornar um item de **diagnóstico** com `setup_status: "DIAGNOSTIC_GUIDE"`, o IP foi bloqueado ou a página caiu em login wall. Aguarde ~30 minutos e tente novamente.
- Com `expandAnswers: false`, respostas longas podem vir **truncadas** pelo Quora (o texto para em "Continue reading"). Ative `expandAnswers` para conteúdo completo.
- `published_at` é capturado **como o Quora exibe** (relativo, ex.: "3y" ou "2 weeks ago") — o Quora não expõe timestamps exatos no DOM público.
- Os nomes de classe do Quora são ofuscados; a extração é estrutural (link de perfil + botão de upvote = card de resposta), o que é robusto, mas pode ocasionalmente deixar passar páginas com formatação incomum.

***

### 🔍 Casos de uso

- Pesquisa de conteúdo / SEO: respostas mais votadas sobre um tema
- Análise de concorrentes: quais perguntas seu público faz
- Base de conhecimento Q\&A para RAG / dados de treinamento
- Descoberta de influenciadores: principais autores de um tópico (via `author` + `author_bio`)

***

*Colete com responsabilidade. Respeite os Termos de Serviço e limites de taxa do Quora. Este actor não é afiliado ao Quora.*

# Actor input Schema

## `urls` (type: `array`):

List of Quora question URLs to scrape (e.g. 'https://www.quora.com/What-is-the-best-way-to-learn-programming'). Provide this, searchQueries, or both.

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

List of keywords to search on Quora. The actor visits https://www.quora.com/search?q=... and extracts question links from the results.

## `maxQuestionsPerSearch` (type: `integer`):

Maximum number of question links to extract per search query

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

Maximum answers to extract per question. The question page itself ships only 4 answers (measured across 6 fetches of 3 different questions). Anything beyond that is fetched with Quora's own paginated GraphQL query, which requires a real browser session (Quora-Formkey + cookies) — measured 20 answers per question on 3 different questions. If the remote browser endpoint is not configured, the run delivers the 4 answers the page carries and logs the gap instead of pretending it delivered more.

## `expandAnswers` (type: `boolean`):

Click 'Continue reading' / 'more' buttons so long answers are extracted in full (Quora truncates long answers by default)

## `proxyConfig` (type: `object`):

Proxy settings. Quora blocks datacenter IPs, so Apify RESIDENTIAL is the default and recommended mode.

## Actor input object example

```json
{
  "urls": [
    "https://www.quora.com/What-is-the-best-way-to-learn-programming",
    "https://www.quora.com/How-do-I-become-a-data-engineer"
  ],
  "searchQueries": [
    "data engineering career",
    "how to learn python",
    "best books for entrepreneurs"
  ],
  "maxQuestionsPerSearch": 5,
  "maxAnswersPerQuestion": 5,
  "expandAnswers": false,
  "proxyConfig": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `url` (type: `string`):

URL of the question page

## `question` (type: `string`):

Question title

## `topic` (type: `string`):

Primary topic of the question

## `upvotes` (type: `string`):

Number of upvotes on the question

## `answers_count` (type: `string`):

Number of answers on the question page

## `followers` (type: `string`):

Number of followers of the question

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

Extracted answers

## `scrapedAt` (type: `string`):

ISO timestamp when the item was scraped

# 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 = {
    "urls": [
        "https://www.quora.com/What-is-the-best-way-to-learn-programming"
    ],
    "searchQueries": [
        "best way to learn programming"
    ],
    "maxQuestionsPerSearch": 5,
    "maxAnswersPerQuestion": 5,
    "expandAnswers": false,
    "proxyConfig": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("viralanalyzer/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 = {
    "urls": ["https://www.quora.com/What-is-the-best-way-to-learn-programming"],
    "searchQueries": ["best way to learn programming"],
    "maxQuestionsPerSearch": 5,
    "maxAnswersPerQuestion": 5,
    "expandAnswers": False,
    "proxyConfig": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("viralanalyzer/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 '{
  "urls": [
    "https://www.quora.com/What-is-the-best-way-to-learn-programming"
  ],
  "searchQueries": [
    "best way to learn programming"
  ],
  "maxQuestionsPerSearch": 5,
  "maxAnswersPerQuestion": 5,
  "expandAnswers": false,
  "proxyConfig": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call viralanalyzer/quora-scraper --silent --output-dataset

```

## MCP server setup

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