# Quora Scraper: Answers, Upvotes, Views & Authors, No Login (`cliqtomedia/quora-scraper`) Actor

Scrape Quora questions and answers by question URL or topic: answer text, author, credential, upvotes, views, shares, comments and dates. Find content ideas, experts and what people ask about your market. No login, public data only.

- **URL**: https://apify.com/cliqtomedia/quora-scraper.md
- **Developed by:** [Cliqto Media](https://apify.com/cliqtomedia) (community)
- **Categories:** Social media
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 75.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.65 / 1,000 answers

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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 reads public Quora questions and topics and returns their answers: text, author, credential, upvotes, views, shares, comments and dates. No login, cookies or API key. The example run reads 1 question with 5 answers in under 10 seconds and costs **$0.0175** on the Free tier.

![Quora Scraper: question URLs and topics to a table of answers with upvotes, views, authors and dates](https://api.apify.com/v2/key-value-stores/bL0cz3mpUJd1KRPBj/records/README-BANNER-HERO-20261031B)

### Table of contents

- [What it does](#what-it-does)
- [How it works](#how-it-works)
- [Data you get](#data-you-get)
- [Quick start](#quick-start)
- [Use cases](#use-cases)
- [Input](#input)
- [Input examples](#input-examples)
- [Output](#output)
- [Pricing](#pricing)
- [Scheduled runs](#scheduled-runs)
- [API, export and integrations](#api-export-and-integrations)
- [Coming from another Quora scraper](#coming-from-another-quora-scraper)
- [Limits](#limits)
- [Troubleshooting](#troubleshooting)
- [FAQ](#faq)
- [Related Actors](#related-actors)
- [Support](#support)

### What it does

The Actor opens public [Quora](https://www.quora.com) pages as a logged-out visitor. Choose one mode:

- **Question URLs** (`question`) — paste question links, such as `https://www.quora.com/What-is-content-marketing`. Answer links (`…/answer/Name`) work too: you get the answers of their question.
- **Topic** (`topic`) — give topic names or topic links, such as `Content Marketing`. The Actor reads the questions of each topic and their answers.

Each answer is one row with the fields of its question. A question without answers is one row too, so you always see what happened to every input.

#### Good fit

- Find what people ask and answer about your product, market or keyword topic.
- Collect answers with upvotes and views to pick content ideas or measure interest.
- Find active authors and their credentials in a topic.
- Feed real questions and answers to research, SEO or AI tools.

#### Not a fit

- Keyword search. Quora search needs a login, so use a topic instead.
- All answers of a big question. Quora hides some answers from logged-out visitors (see [Limits](#limits)).
- Profiles, Spaces, followers or private content. The Actor does not log in and does not bypass a login, CAPTCHA or paywall.
- Quora in other languages (`fr.quora.com`, `de.quora.com` and others). Only English `www.quora.com` is supported.

> **👉 [Try it now: open the input form](https://console.apify.com/actors/loy90R8yZh8qgv8iS/input)**

### How it works

1. The Actor opens each question or topic page on `www.quora.com` as a logged-out visitor, through a residential proxy by default.
2. It reads the answers Quora shows on that page and its next pages, up to your limit, and skips Quora's own AI bot answers.
3. It saves one row per answer (or one row per question without answers) to the Dataset, and counts, stop reason and warnings to `RUN_SUMMARY`.

> **👉 [Try it now: open the input form](https://console.apify.com/actors/loy90R8yZh8qgv8iS/input)**

### Data you get

Each row is one answer: `question`, `questionUrl`, `questionAnswerCount`, `answerId`, `answerUrl`, `text`, author (`authorName`, `authorProfileUrl`, `authorCredential`, `authorIsAnonymous`), metrics (`upvotes`, `views`, `shares`, `comments`), `createdAt`, `updatedAt`, `language`, and for topic runs `topic` and `topicUrl`. Every row also has `status`, `error`, `sourceInput` and `fetchedAt`.

A missing number is `null`, not `0`. `0` means Quora shows zero.

The run report `RUN_SUMMARY` (in the Key-value store) has counts, the stop reason and warnings.

This Actor is independent. It is not made or endorsed by Quora. Answers belong to their authors; check the [Quora Terms of Service](https://www.quora.com/about/tos) before you reuse the text. Quora's terms and robots.txt restrict automated collection and reuse of its content, including for training AI models; make sure your use is allowed.

> **👉 [Try it now: open the input form](https://console.apify.com/actors/loy90R8yZh8qgv8iS/input)**

### Quick start

[![Input form: what to scrape, question URLs and topics (box 1), max answers per question (box 2), run options (box 3)](https://api.apify.com/v2/key-value-stores/bL0cz3mpUJd1KRPBj/records/quick-start-form-20261031b.png)](https://console.apify.com/actors/loy90R8yZh8qgv8iS/input)

1. Open the **Input** tab. Keep **What to scrape** (`mode`) at `Question URLs` and the prefilled **Question URLs** (`questionUrls`) `https://www.quora.com/What-is-content-marketing`, or paste your own links. For a topic, choose `Topic` and fill **Topics** (`queries`) instead (box 1).
2. Keep **Max answers per question** (`maxAnswersPerQuestion`) at the prefilled 5, or set up to 50 (box 2).
3. Keep the run options: 600 seconds timeout and 512 MB memory. The residential proxy is already set under **Advanced** (box 3).
4. Click **Start** in the bar at the bottom of the page, then open the **Output** tab. The **Answers** view shows the answer text, author, upvotes and views of each answer (box 4).

   [![Output table of the prefill run: answer text, preview flag, author, credential, upvotes and views columns (box 4)](https://api.apify.com/v2/key-value-stores/bL0cz3mpUJd1KRPBj/records/output-table-20261031.png)](https://api.apify.com/v2/key-value-stores/bL0cz3mpUJd1KRPBj/records/output-table-20261031.png)

Expected result: 5 answers of the question in under 10 seconds, each with `status: "complete"`.

> **👉 [Try it now: open the input form](https://console.apify.com/actors/loy90R8yZh8qgv8iS/input)**

### Use cases

| Job | Input | Key fields |
| --- | --- | --- |
| Content ideas from real questions | `topic` mode, `maxAnswersPerQuestion: 0` | `question`, `questionAnswerCount` |
| See which answers people like | question URLs | `upvotes`, `views`, `text` |
| Find experts in a topic | `topic` mode | `authorName`, `authorCredential`, `authorProfileUrl` |
| Brand or competitor mentions in answers | question URLs about your market | `text`, `createdAt`, `answerUrl` |
| Data for AI and research | `topic` mode | `question`, `text`, `language` |

> **👉 [Try it now: open the input form](https://console.apify.com/actors/loy90R8yZh8qgv8iS/input)**

### Input

| Field | Name in Console | Type | Default | Allowed | What it does |
| --- | --- | --- | --- | --- | --- |
| `mode` | What to scrape | string | `question` | `question`, `topic` | Question links or topics. |
| `questionUrls` | Question URLs | list of strings | — (example: 1 URL) | up to 100 quora.com question or answer URLs | Questions to read in `question` mode. |
| `queries` | Topics | list of strings | — | up to 5 topic names or topic URLs | Topics to read in `topic` mode. |
| `maxQuestions` | Max questions | integer | empty | 1–100 | Topic: questions per topic (empty = 20). Question URLs: only the first N URLs (empty = all). |
| `maxAnswersPerQuestion` | Max answers per question | integer | `5` | 0–50 | Answers per question in Quora's order. `0` returns the question only. |
| `includeRelatedAnswers` | Include related answers | boolean | `false` | — | Also return answers Quora shows from similar questions (`answerType: "related"`). |
| `proxyConfiguration` | Proxy | object | Apify residential, US | — | Quora blocks most datacenter traffic. Keep the default. |

Other notes:

- The Actor uses only the list of the chosen mode. In `question` mode `queries` is ignored, in `topic` mode `questionUrls` is ignored.
- Duplicate URLs (`?share=1`, `m.quora.com`, answer links of the same question) are read once. `RUN_SUMMARY` counts them as `duplicatesSkipped`.
- A bad URL (not Quora, a profile, a topic in question mode) is a free row with `status: "error"`. The run goes on.
- More than 100 URLs, more than 5 topics, or limits out of range: the run stops at once with an input error.

> **👉 [Try it now: open the input form](https://console.apify.com/actors/loy90R8yZh8qgv8iS/input)**

### Input examples

#### Answers of a few questions

```json
{
  "mode": "question",
  "questionUrls": [
    "https://www.quora.com/What-is-content-marketing",
    "https://www.quora.com/How-do-I-search-keywords-for-creating-content"
  ],
  "maxAnswersPerQuestion": 10
}
```

Expected result: up to 10 answers for each question, ordered as Quora shows them.

#### Questions and answers of a topic

```json
{
  "mode": "topic",
  "queries": ["Content Marketing", "https://www.quora.com/topic/Search-Engine-Optimization-SEO"],
  "maxQuestions": 20,
  "maxAnswersPerQuestion": 3
}
```

Expected result: up to 20 questions per topic with up to 3 answers each, about 1–2 minutes.

#### Only the questions of a topic

```json
{
  "mode": "topic",
  "queries": ["Content Marketing"],
  "maxQuestions": 50,
  "maxAnswersPerQuestion": 0
}
```

Expected result: one row per question with `question`, `questionUrl` and `questionAnswerCount`, no answers.

> **👉 [Try it now: open the input form](https://console.apify.com/actors/loy90R8yZh8qgv8iS/input)**

### Output

#### Output example

One answer row from the example run (text shortened). The question has 371 answers on Quora; the example asks for 5.

```json
{
  "recordType": "answer",
  "status": "complete",
  "questionUrl": "https://www.quora.com/What-is-content-marketing",
  "questionId": 839059,
  "question": "What is content marketing?",
  "questionAnswerCount": 371,
  "answerId": 272154354,
  "answerUrl": "https://www.quora.com/What-is-content-marketing/answer/Otis-Kopp",
  "answerType": "direct",
  "relatedQuestionUrl": null,
  "relatedQuestion": null,
  "text": "Content marketing is a strategy that marketers use to accurately pinpoint the particular interests of consumers, through the creation of advertising campaigns designed to appeal to specific areas of buyer interest. …",
  "isTruncated": false,
  "authorName": "Otis Kopp",
  "authorProfileUrl": "https://www.quora.com/profile/Otis-Kopp",
  "authorCredential": "Marketing Professional",
  "authorIsAnonymous": false,
  "upvotes": 10,
  "views": 2960,
  "shares": 0,
  "comments": 2,
  "createdAt": "2021-03-24T03:31:06Z",
  "updatedAt": null,
  "language": "en",
  "isAiAnswer": false,
  "topic": null,
  "topicUrl": null,
  "sourceInput": "https://www.quora.com/What-is-content-marketing",
  "source": "quora.com",
  "fetchedAt": "2026-10-15T10:55:08.919Z",
  "error": null
}
```

#### Output fields

| Field | Type | Can be null? | Meaning |
| --- | --- | --- | --- |
| `recordType` | string | no | `answer`, `question` (a question row without answers) or `topic` (a topic that does not exist or could not be read). |
| `status` | string | no | `complete`, `partial` (the run stopped while reading this question), `not_found` (Quora says the question or topic does not exist) or `error` (bad input or Quora could not be read). |
| `questionUrl` | string | yes | Question page on www.quora.com. |
| `questionId` | number | yes | Quora question ID. |
| `question` | string | yes | Question title. |
| `questionAnswerCount` | number | yes | Answer count Quora shows for the question. It can be bigger than the answers you can get as a visitor. |
| `answerId` | number | yes | Quora answer ID. `null` on question rows. |
| `answerUrl` | string | yes | Link to the answer. |
| `answerType` | string | yes | `direct` (posted on this question) or `related` (from a similar question, only with `includeRelatedAnswers`). |
| `relatedQuestionUrl`, `relatedQuestion` | string | yes | The similar question of a `related` answer. |
| `text` | string | yes | Answer text as plain text. Lists and line breaks are kept. |
| `isTruncated` | boolean | yes | `true` when Quora shows only a preview of this answer to visitors who are not logged in (some Quora+ answers); `text` then ends with "...". `null` on question and topic rows. |
| `authorName` | string | yes | Author name. `null` for anonymous answers. |
| `authorProfileUrl` | string | yes | Author profile link. |
| `authorCredential` | string | yes | Author credential shown with the answer, such as a job title. |
| `authorIsAnonymous` | boolean | yes | `true` when the answer is anonymous. |
| `upvotes`, `views`, `shares`, `comments` | number | yes | Metrics Quora shows. `null` = Quora did not give the number. |
| `createdAt`, `updatedAt` | string (ISO 8601) | yes | When the answer was posted and last changed. |
| `language` | string | yes | Answer language code, such as `en`. |
| `isAiAnswer` | boolean | yes | `true` when Quora marks the author as an AI account. `null` when the author is unknown. |
| `topic`, `topicUrl` | string | yes | The topic of the row in `topic` mode. |
| `sourceInput` | string | no | The input line this row comes from. |
| `source` | string | no | Always `quora.com`. |
| `fetchedAt` | string (ISO 8601) | no | When the row was read. |
| `error` | string | yes | What went wrong on `error` rows. `null` otherwise, also on `not_found`. |

#### Where to find results

- **Answers** view — the main table: question, text, preview flag, author, credential, upvotes, views, comments, date, and the `status` and `error` of each row.
- **Question and status of each row** view — one look at every input: question, answer count, topic, `status` and `error`.
- **Key-value store → `RUN_SUMMARY`** — counts (`answers`, `questions`, `topics`, `notFound`, `errors`, `hiddenAnswers`, `duplicatesSkipped`), `stopReason` and `warnings`.

> **👉 [Try it now: open the input form](https://console.apify.com/actors/loy90R8yZh8qgv8iS/input)**

### Pricing

You pay per event. Prices on the Free plan (higher plans pay less):

| Event | Price | When |
| --- | ---: | --- |
| Actor start | $0.01 per GB of memory, at least $0.01 | Once per run. The default 512 MB run = **$0.01**. The start fee grows with memory: a 2 GB run pays $0.02. |
| Question | $0.0035 | Each question Quora returns, with or without answers, or says it does not exist. |
| Answer | $0.0008 | Each answer row. |
| Topic | $0.005 | Each topic Quora returns, with or without questions, or says it does not exist. |

Free: rows with `status: "error"` (bad input, Quora could not be read), duplicate URLs and questions the run did not reach. Apify platform usage is included in the event prices.

#### Cost examples

| Run | Events | Cost on Free plan |
| --- | --- | ---: |
| Example: 1 question, 5 answers | start + 1 question + 5 answers | $0.0175 |
| 10 questions, up to 50 answers (measured: 269 answers) | start + 10 questions + 269 answers | $0.2602 |
| 1 topic, 20 questions, 5 answers each | start + 1 topic + 20 questions + 100 answers | $0.165 |
| 1 topic, 50 questions, questions only (`maxAnswersPerQuestion: 0`) | start + 1 topic + 50 questions | $0.19 |
| 1 question URL that does not exist | start + 1 question | $0.0135 |
| Only bad URLs, or Quora could not be read | start only | $0.01 |

To cap a run, set **Maximum charge per run** in the run options. The run stops at the cap with `status: "partial"` and `stopReason: "CHARGE_LIMIT"` and keeps the rows it already saved.

> **👉 [Try it now: open the input form](https://console.apify.com/actors/loy90R8yZh8qgv8iS/input)**

### Scheduled runs

Use [Apify schedules](https://docs.apify.com/platform/schedules) to read the same topics every day or week. Every run returns what Quora shows at that time; it does not remember earlier runs. To keep only new answers, compare `answerId` with your earlier data.

> **👉 [Try it now: open the input form](https://console.apify.com/actors/loy90R8yZh8qgv8iS/input)**

### API, export and integrations

- **API:** start the Actor with the [Apify API](https://docs.apify.com/api/v2) and the same JSON input. Read rows from the run's default dataset.
- **Export:** download the dataset as JSON, CSV, Excel, XML or HTML.
- **Integrations:** send results to Google Sheets, Make, Zapier, n8n or a webhook when the run ends.

#### Use with AI agents (MCP)

- MCP server with only this Actor: `https://mcp.apify.com?tools=cliqtomedia/quora-scraper` ([Apify MCP docs](https://docs.apify.com/platform/integrations/mcp)).
- Smallest useful input: `{"mode": "question", "questionUrls": ["https://www.quora.com/What-is-content-marketing"], "maxAnswersPerQuestion": 5}`.
- Key output fields: `question` (question title), `text` (answer text), `upvotes` and `views` (interest), `authorName` and `authorCredential` (who answers), `status` (`complete`, `not_found`, `error`).
- A small run takes under 10 seconds and costs about $0.0175. Limits: up to 100 question URLs or 5 topics, up to 100 questions per topic, up to 50 answers per question. The default run timeout is 600 seconds.

> **👉 [Try it now: open the input form](https://console.apify.com/actors/loy90R8yZh8qgv8iS/input)**

### Coming from another Quora scraper

Rows here are flat: one row = one answer with its question. If your old tool had nested fields, map them like this:

| Nested field | This Actor |
| --- | --- |
| `answer.text`, `text` | `text` |
| `answer.url` | `answerUrl` |
| `answer.id` | `answerId` |
| `answer.posted_at`, `posted_at` | `createdAt` |
| `author.name`, `author.url`, `author.credential` | `authorName`, `authorProfileUrl`, `authorCredential` |
| `metrics.upvotes`, `metrics.views`, `metrics.shares`, `metrics.comments` | `upvotes`, `views`, `shares`, `comments` |
| `question.title`, `question.url`, `question.id` | `question`, `questionUrl`, `questionId` |
| `question.metrics.answers` | `questionAnswerCount` |

The text keeps list markers and line breaks, so it can differ in formatting from tools that join everything into one line.

> **👉 [Try it now: open the input form](https://console.apify.com/actors/loy90R8yZh8qgv8iS/input)**

### Limits

- **Hidden answers.** For big questions Quora shows only part of the answers to logged-out visitors. When a question gives fewer answers than you asked for and fewer than its `questionAnswerCount`, `RUN_SUMMARY` counts it in `hiddenAnswers` and adds a warning. The Actor does not log in to get the rest.
- **Quora+ previews.** Some answers are Quora+ content. Quora sometimes shows a logged-out visitor only the first lines of such an answer. Then `text` ends with "..." and `isTruncated` is `true`. The Actor does not log in or bypass the paywall to get the full text.
- **Quora's AI bot answers** are skipped. They are not posts of Quora users. `RUN_SUMMARY` counts them as `machineAnswersSkipped`.
- **Empty topics.** Some topics show no questions to a logged-out visitor. You get a warning and no rows for that topic.
- **Timeout.** The default timeout is 600 seconds: in measured runs, 100 question URLs with up to 10 answers took 350 seconds and 5 topics × 100 questions with up to 5 answers took 985 seconds. For bigger runs, raise the timeout in the run options. When time runs out, the run stops on its own: you keep the saved rows, `RUN_SUMMARY` has `stopReason: "TIMEOUT"`, and the question being read is `partial`.
- **Answer order** is Quora's order. The Actor does not sort by upvotes or date.

> **👉 [Try it now: open the input form](https://console.apify.com/actors/loy90R8yZh8qgv8iS/input)**

### Troubleshooting

#### Fewer answers than `maxAnswersPerQuestion`

The question may have fewer answers, or Quora hides some from visitors. Check `questionAnswerCount` and `hiddenAnswers` in `RUN_SUMMARY`.

#### A row has `status: "not_found"`

Quora says the question or topic does not exist. Open the link in a private browser window. For topics, try the exact topic URL from Quora, such as `https://www.quora.com/topic/Search-Engine-Optimization-SEO`.

#### A row has `status: "error"`

Read `error`. Most often the line is not a Quora question URL (a profile, a Space, another language site). Fix the line and run again.

#### The run failed with "Quora could not be read"

Quora blocked the connection. Keep the default residential proxy and run again later.

> **👉 [Try it now: open the input form](https://console.apify.com/actors/loy90R8yZh8qgv8iS/input)**

### FAQ

#### Do I need a Quora account?

No. The Actor reads only what a logged-out visitor sees.

#### Can I search Quora by keyword?

No. Quora search needs a login. Use a topic close to your keyword instead.

#### Why is the answer count bigger than the answers I got?

`questionAnswerCount` is Quora's own count. Quora shows only part of the answers to visitors on big questions.

#### Why is there a question fee and not only an answer fee?

Each question needs its own page load through a residential proxy, even when it has no answers. The question fee pays for that work, so the answer price can stay low.

#### Why is a metric `null` and not `0`?

`null` means Quora did not give the number. `0` means Quora shows zero.

> **👉 [Try it now: open the input form](https://console.apify.com/actors/loy90R8yZh8qgv8iS/input)**

### Related Actors

- [Reddit Scraper](https://apify.com/cliqtomedia/reddit-scraper) — posts and comments from subreddits, the other big place where people ask and answer.
- [Stack Overflow & Stack Exchange Q\&A Scraper](https://apify.com/cliqtomedia/stack-exchange-scraper) — questions and answers from Stack Overflow and other Stack Exchange sites.
- [Hacker News Scraper](https://apify.com/cliqtomedia/hacker-news-stories-comments-scraper) — stories and comment threads from Hacker News.
- [Google Autocomplete Scraper](https://apify.com/cliqtomedia/google-autocomplete-scraper) — the questions people type into Google, next to the ones they ask on Quora.
- [Medium Article Scraper](https://apify.com/cliqtomedia/medium-articles-scraper) — long-form articles by tag, author or publication.

> **👉 [Try it now: open the input form](https://console.apify.com/actors/loy90R8yZh8qgv8iS/input)**

### Support

For help, open an issue on this Actor's **Issues** tab in Apify Store. Share the run ID and your input. Remove tokens and private information.

> **👉 [Try it now: open the input form](https://console.apify.com/actors/loy90R8yZh8qgv8iS/input)**

# Changelog

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

# Actor input Schema

## `mode` (type: `string`):

Question URLs: answers of the Quora questions you paste. Topic: questions of a Quora topic and their answers. Keyword search is not available on Quora without login, so use a topic instead.

## `questionUrls` (type: `array`):

Quora question pages, e.g. https://www.quora.com/What-is-content-marketing. Answer links (…/answer/Name) work too and give the answers of their question. Up to 100. Used when "What to scrape" is Question URLs.

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

Quora topic names or topic URLs, e.g. "Content Marketing" or https://www.quora.com/topic/Search-Engine-Optimization-SEO. Up to 5. Each topic Quora checks (found, empty or not found) is one topic event. Used when "What to scrape" is Topic.

## `maxQuestions` (type: `integer`):

Topic: questions to read per topic (1–100; empty = 20). Question URLs: read only the first N URLs (empty = all).

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

Answers per question in Quora's order (0–50). Each question Quora checks is one question event; each answer is one answer event. 0 returns the question only.

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

Quora also shows answers to similar questions on a question page. On: they are returned too, marked answerType "related" with the question they belong to. Off: only answers posted on the question itself.

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

Quora blocks most datacenter traffic; keep the default residential proxy.

## Actor input object example

```json
{
  "mode": "question",
  "questionUrls": [
    "https://www.quora.com/What-is-content-marketing"
  ],
  "maxAnswersPerQuestion": 5,
  "includeRelatedAnswers": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

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

One row per answer: question, text, author, upvotes, views, comments, date.

## `questions` (type: `string`):

Every row with its question, status and note (not found, errors).

## `runSummary` (type: `string`):

Status, stop reason and counts.

# 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 = {
    "mode": "question",
    "questionUrls": [
        "https://www.quora.com/What-is-content-marketing"
    ],
    "maxAnswersPerQuestion": 5,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("cliqtomedia/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 = {
    "mode": "question",
    "questionUrls": ["https://www.quora.com/What-is-content-marketing"],
    "maxAnswersPerQuestion": 5,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("cliqtomedia/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 '{
  "mode": "question",
  "questionUrls": [
    "https://www.quora.com/What-is-content-marketing"
  ],
  "maxAnswersPerQuestion": 5,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}' |
apify call cliqtomedia/quora-scraper --silent --output-dataset

```

## MCP server setup

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