# Quora Scraper — Questions, Answers, Profiles & Spaces (`brilliant_gum/quora-scraper`) Actor

Scrape Quora questions, answers, search, profiles, Spaces and Topics without login. Full answer text and HTML, per-answer views and upvotes, AI-answer flag, author credentials and lead contacts.

- **URL**: https://apify.com/brilliant\_gum/quora-scraper.md
- **Developed by:** [Yuliia Kulakova](https://apify.com/brilliant_gum) (community)
- **Categories:** Social media, Lead generation, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $15.00 / 1,000 answers

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, profiles, spaces & topics, no login

![Quora Scraper](https://api.apify.com/v2/key-value-stores/IuFu0Cw6PpOkNkDV7/records/quora-scraper-banner.png)

Scrape Quora questions and answers, run keyword searches, and pull profiles, Spaces and Topics — all from public pages, with **no login, no cookies and nothing to set up**.

One actor, four modes. Paste a mix of links and each one is recognised automatically, so questions, answers, profiles, Spaces and Topics can share a run.

- **Question + answers** — a question page → the question (title, answer and follower counts, topics) plus its top answers with full text and HTML, author, credential, upvotes, views, shares, comment counts and dates.
- **Keyword search** — a phrase → matching Quora pages → each one scraped like a pasted link.
- **Profile** — a user's credential and follower / answer / view stats, plus their answers and posts, with optional public contact details for lead generation.
- **Space / Topic** — a Space (`name.quora.com`) or Topic (`/topic/…`) page plus its feed.

**Who it's for:** market and audience research, content and SEO mining, AI and NLP datasets, and expert or lead discovery — anywhere you need the real questions people ask and the answers that rank on Quora.

***

### What this gives you that a plain text dump does not

- **You can tell a human answer from a machine one.** Quora now publishes answers written by its own
  assistant alongside people's. Every answer row carries `isAiAnswer`, so a research set, a training
  corpus or a sentiment study can keep the two apart instead of silently mixing them.
- **Engagement per answer, not just per question.** `viewCount`, `upvotes`, `shareCount` and
  `commentCount` sit on each answer, and on question pages `position` / `isTopAnswer` rank the answers by
  upvotes — so you can see which answer carried the thread, not only that the thread was popular.
- **Formatting and citations survive.** Next to plain `text`, each answer comes as `html` with links
  intact, so the sources an author cited are still there after scraping.
- **Runs can watch for change.** `onlyNewItems` skips what earlier runs already saved, and `monitorMode`
  with a `webhookUrl` posts only what is new — a scheduled "what appeared since yesterday" needs no code.
- **Rows join back to your input.** Quora renames and merges questions; every question row keeps the
  link you asked for in `requestedUrl`, next to the page it actually landed on.
- **Answers from equivalent questions are kept — and labelled.** Quora merges duplicate questions and
  shows their answers under "Originally Answered". Those rows carry `originallyAnsweredQuestion` and
  `originallyAnsweredUrl`, so you get the answers a reader sees without mistaking them for answers
  written to this exact wording.
- **Ads are left out.** Paid answers Quora mixes into question pages and feeds are never saved or billed.
- **Nothing is quietly filled in.** A field Quora does not show to signed-out visitors stays `null`
  instead of being guessed, and a cut preview says so in `isTextTruncated`. When a question lists answers
  but Quora ships none of them to a signed-out visitor, the run says that in plain words instead of
  leaving you to guess whether the answers were lost.
- **An empty result is never a green run.** If none of the requested pages could be read, the run fails
  with the reason instead of finishing "Succeeded" with an empty dataset.
- **Your spending limit is respected.** When a run reaches the maximum cost per run you set, it stops.

### Key features

All of this works without an account or cookies:

- **Answer text + HTML, with an honest preview flag** — each answer as plain `text` and as lightweight `html` with **links preserved** (internal links, external citations, formatting). Images in an answer come as full-size `images[]` links and inline in `html`, so an image-only answer is never an empty row. A question page usually gives the whole answer; Quora occasionally serves only a preview of a long answer there too, and more often on profile and Space feeds — those rows carry `isTextTruncated: true` so a fragment never passes for the full text.
- **Per-answer engagement** — `viewCount`, `upvotes`, `shareCount` and `commentCount`, plus `createdAt` and `updatedAt`.
- **Author block on every answer** — `authorName`, `authorId`, `authorUrl`, `authorCredential` (the credential line shown with that answer), `authorImage`, `authorIsVerified`, and the author's lifetime `authorViewCount` where Quora shows it.
- **AI-answer detection** — `isAiAnswer` marks answers written by Quora's assistant.
- **Question metadata** — `topics[]`, `answerCount`, `followerCount` and `commentCount`.
- **Profile stats** — `followerCount`, `followingCount`, `answerCount`, `questionCount`, `postCount`, lifetime `viewCount`, `lastMonthViews`, `credential`, `bio` and `isVerified`.
- **Space & Topic pages** — name, description, follower count and image, plus the questions and posts in their feed.
- **Lead enrichment (optional)** — `scrapeAuthorProfiles` opens each answer author's profile and adds an `author` row with the `links[]` from their Quora bio, an `isLead` flag and a `leadScore`; `extractAuthorContacts` adds public `emails[]` from the person's own website linked there — addresses on that site's domain or offered as its mail link, each checked for a mail server. In Profile mode `extractAuthorContacts` adds all of these to the profile row.
- **Incremental + monitoring** — `onlyNewItems` skips items saved by earlier runs; `monitorMode` + `webhookUrl` POST only newly seen items to your endpoint.
- **Flexible inputs** — `startUrls` (links), `identifiers` (bare slugs such as `Adam-DAngelo`) and `searchTerms`. A pasted Quora search link runs as a keyword search. Common alternative field names (`urls`, `usernames`, `queries`, `maxResults`, …) are accepted too.

***

### Input

Give links, identifiers or search terms — or any mix of them. Everything you enter is scraped in one run.

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | enum | `question` | `question` / `search` / `profile` / `space`. Links are recognised automatically; the mode decides how bare identifiers are read. |
| `startUrls` | array | `[]` | Quora links — question, answer, profile, Space (`name.quora.com`; old `quora.com/q/name` links are converted), Topic (`/topic/…`) or a Quora search link. In JSON: `[{ "url": "…" }]`. Alias `urls` (plain strings). |
| `identifiers` | array | `[]` | Bare slugs / usernames (e.g. `Adam-DAngelo` in Profile mode, `quorablog` in Space mode), read per `mode`. Full links work here too. Aliases `usernames` / `profiles`. |
| `searchTerms` | array | `[]` | Phrases to search for, one search per phrase. Aliases `queries` / `searchQueries`. |
| `searchType` | enum | `question` | `all` / `question` / `profile` / `space` / `topic` — which kind of Quora page a search returns. `question` gives question pages with their answers. |
| `maxItems` | integer | `100` | Maximum rows saved in the run (0 = no limit). Alias `maxResults`. |
| `maxAnswers` | integer | `20` | Answers kept per question page; on a profile, answers and posts combined (0 = all that Quora shows). Alias `maxAnswersPerQuestion`. |
| `includeAnswers` | boolean | `true` | Save answer rows. Off = a question page gives only the question, a profile only the profile. |
| `scrapeAuthorProfiles` | boolean | `false` | On question pages, add one `author` row per answer author (billed as a profile). |
| `extractAuthorContacts` | boolean | `false` | With author enrichment or in Profile mode: public e-mails from the website linked in the person's Quora bio. |
| `authorFilter` | string | `""` | Keep only answers whose author name or slug contains this text (case-insensitive). |
| `onlyNewItems` | boolean | `false` | Skip items that earlier runs with this option on already saved. |
| `excludeEmptyFields` | boolean | `false` | Leave empty fields out of each row. |
| `cookies` | array | — | **Optional**, never required. See the FAQ. |
| `monitorMode` | boolean | `false` | Like `onlyNewItems`, plus a POST of the new items to `webhookUrl` after the run. |
| `webhookUrl` | string | `""` | Where monitor mode sends its POST. |
| `proxyConfiguration` | object | preset | Connection — already set up for Quora; nothing to change. |

#### Examples

**Question + answers**

```json
{
  "mode": "question",
  "startUrls": [
    { "url": "https://www.quora.com/What-is-machine-learning-4" }
  ],
  "maxAnswers": 10
}
```

**Keyword search**

```json
{
  "mode": "search",
  "searchTerms": ["machine learning"],
  "searchType": "question",
  "maxItems": 50
}
```

**Profile with public contact details**

```json
{
  "mode": "profile",
  "identifiers": ["Adam-DAngelo"],
  "extractAuthorContacts": true,
  "maxItems": 20
}
```

**Answer authors as leads**

```json
{
  "mode": "question",
  "startUrls": [
    { "url": "https://www.quora.com/What-is-machine-learning-4" }
  ],
  "scrapeAuthorProfiles": true,
  "extractAuthorContacts": true,
  "maxItems": 30
}
```

**Topic / Space**

```json
{
  "mode": "space",
  "startUrls": [
    { "url": "https://www.quora.com/topic/Computer-Programming" },
    { "url": "https://quorablog.quora.com/" }
  ],
  "maxItems": 100
}
```

**Daily monitor of new answers** (run it on a schedule)

```json
{
  "startUrls": [
    { "url": "https://www.quora.com/What-is-machine-learning-4" }
  ],
  "monitorMode": true,
  "webhookUrl": "https://example.com/your-webhook"
}
```

***

### Output

One flat JSON row per item, tagged by `type`. All rows carry `scrapedAt`; rows found by a keyword search carry `sourceQuery`; answer rows from a profile carry `fromProfile`. Samples below are real output, trimmed for length.

#### Question (`type: "question"`)

```json
{
  "type": "question",
  "questionId": "4256391",
  "url": "https://www.quora.com/What-is-machine-learning-4",
  "title": "What is machine learning?",
  "answerCount": 253,
  "followerCount": 573,
  "viewCount": null,
  "commentCount": 11,
  "topics": ["Machine Learning", "Computer Science", "Algorithms", "Technology", "Artificial Intelligence", "Data Science"],
  "askedAt": null,
  "updatedAt": null,
  "scrapedAt": "2026-09-14T08:52:06.179Z",
  "requestedUrl": "https://www.quora.com/What-is-machine-learning-4"
}
```

**Fields:** `type, questionId, url, title, answerCount, followerCount, viewCount, commentCount, topics[], askedAt, updatedAt, scrapedAt, requestedUrl` (+ `sourceQuery` from a keyword search). Questions listed in a Space or Topic feed may lack answer, follower and comment counts.

> `viewCount` and `askedAt` are `null` for signed-out visitors — Quora no longer shows them (see Limitations).

#### Answer (`type: "answer"`)

```json
{
  "type": "answer",
  "answerId": "1477743877991986",
  "url": "https://www.quora.com/What-is-machine-learning-4/answers/1477743877991986",
  "text": "Machine learning (ML) is a branch of computer science that builds algorithms and statistical models enabling systems to improve performance on tasks through data, rather than through explicit, rule‑based programming. …",
  "html": "<p>Machine learning (ML) is a branch of computer science that builds algorithms and statistical models enabling systems to improve performance on tasks through data, rather than through explicit, rule‑based programming. …</p>",
  "images": [],
  "upvotes": 0,
  "viewCount": 1,
  "shareCount": 0,
  "commentCount": 0,
  "isAuthorAnon": false,
  "isAiAnswer": true,
  "createdAt": "2025-09-06T10:44:13.071Z",
  "updatedAt": null,
  "isTextTruncated": false,
  "authorName": "Assistant",
  "authorUrl": "https://www.quora.com/profile/Assistant-106",
  "authorId": "3086901856",
  "authorCredential": null,
  "authorIsVerified": false,
  "authorViewCount": null,
  "questionTitle": "What is machine learning?",
  "questionUrl": "https://www.quora.com/What-is-machine-learning-4",
  "questionId": "4256391",
  "scrapedAt": "2026-09-14T09:35:07.238Z",
  "originallyAnsweredQuestion": null,
  "originallyAnsweredUrl": null,
  "isTopAnswer": false,
  "position": 5
}
```

**Fields:** `type, answerId, url, text, html, images[], upvotes, viewCount, shareCount, commentCount, isAuthorAnon, isAiAnswer, createdAt, updatedAt, isTextTruncated, authorName, authorUrl, authorId, authorCredential, authorImage, authorIsVerified, authorViewCount, questionTitle, questionUrl, questionId, scrapedAt, originallyAnsweredQuestion, originallyAnsweredUrl, isTopAnswer, position` (+ `fromProfile` in profile mode, `sourceQuery` from a keyword search). On question pages `position` and `isTopAnswer` rank the collected answers by upvotes — the question's own answers first; answers from profile and Space feeds carry no `position`, `isTopAnswer` or `originallyAnswered…` fields. `originallyAnsweredQuestion` / `originallyAnsweredUrl` name the question an answer was written for when Quora lists it under "Originally Answered", and are `null` otherwise.

#### Profile (`type: "profile"`)

```json
{
  "type": "profile",
  "authorName": "Adam D'Angelo",
  "authorUrl": "https://www.quora.com/profile/Adam-DAngelo",
  "authorId": "335",
  "authorCredential": "Quora CEO",
  "authorIsVerified": true,
  "authorFollowerCount": 545936,
  "credential": "Quora CEO",
  "followerCount": 545936,
  "followingCount": 699,
  "answerCount": 998,
  "questionCount": 1053,
  "postCount": 212,
  "viewCount": 42605686,
  "lastMonthViews": 32907,
  "isVerified": true,
  "scrapedAt": "2026-09-12T12:39:14.673Z",
  "url": "https://www.quora.com/profile/Adam-DAngelo"
}
```

**Fields:** `type, authorName, authorUrl, authorId, authorCredential, authorImage, authorIsVerified, authorFollowerCount, bio, credential, followerCount, followingCount, answerCount, questionCount, postCount, viewCount, lastMonthViews, isVerified, url, scrapedAt`. With `extractAuthorContacts` the row also carries `links[]`, `emails[{email, role, source, mxFound}]`, `isLead` and `leadScore`.

#### Author (`type: "author"`) — with `scrapeAuthorProfiles`

**Fields:** the profile fields above plus `links[]`, `isLead` and `leadScore`; with `extractAuthorContacts` also `emails[{email, role, source, mxFound}]`. `isLead` is `true` when the person can be reached outside Quora: a personal website in their Quora bio or a public address. A bio that only cites reference sites does not count.

#### Post (`type: "post"`) — from profiles and Spaces

**Fields:** `type, postId, url, title, text, images[], isTextTruncated, upvotes, viewCount, commentCount, shareCount, createdAt, authorName, authorUrl, authorId, authorCredential, authorImage, authorIsVerified, spaceName, spaceUrl, scrapedAt`.

#### Space (`type: "space"`) and Topic (`type: "topic"`)

**Space fields:** `type, spaceId, url, name, description, followerCount, icon, scrapedAt`.
**Topic fields:** `type, topicId, url, name, description, followerCount, questionCount, image, scrapedAt`.

***

### Pricing

**Pay per result.** Every saved row is one billing event — a question, an answer, a profile (an enriched answer author counts as a profile), a Space or Topic, or a post — at the price shown on this actor's pricing panel. Public contact e-mails found for a person are a separate event, charged only when at least one address is found. A start fee applies per run, counted per GB of memory.

On top of the result price you pay the **platform usage** of your run (compute and data transfer), billed by Apify at its standard rates and shown on every run. In our test runs it came to about $4 per 1,000 rows on average — from about $1 on Space pages to about $9 on keyword searches, where many pages give only a question row.

- Duplicate rows inside a run are neither saved nor billed.
- Items with no content at all — for example a post that only re-shares another item — are neither saved nor billed.
- `onlyNewItems` skips what earlier runs already collected, so a scheduled run does not pay twice for the same answer.
- `maxItems` and Apify's maximum cost per run both cap a run; it stops when either is reached.

***

### Use cases

- **Audience & topic research** — pull the real questions people ask in a niche, their `topics[]`, follower and answer counts and the most upvoted answers to understand demand and language.
- **SEO & content mining** — harvest question titles and full answer text/HTML (with links) to find content gaps, cited sources and questions worth targeting.
- **AI and NLP datasets** — question–answer pairs with engagement signals, with `isAiAnswer` to keep machine-written answers out of human-only data.
- **Expert & lead discovery** — rank contributors by views, verification and credentials; optionally add outbound links and public e-mails for outreach.
- **Brand & topic monitoring** — schedule `monitorMode` with a `webhookUrl` (or `onlyNewItems`) to get pinged when new answers appear on a question or a Space, or when a competitor's profile publishes something new.

***

### Honest limitations

These come from how Quora treats signed-out visitors — read them before you run.

- **Only the top answers.** Quora shows signed-out visitors the top answers of a question — usually about half a dozen — and scrolling loads related content, not more answers. A higher `maxAnswers` cannot add more.
- **Some questions show no answers of their own.** To a signed-out visitor Quora sometimes lists only answers from equivalent questions (saved and labelled, see above) or no answers at all. In the second case the question row is still saved and the run log names the question.
- **A few fields are `null` for signed-out visitors.** Question `viewCount` and `askedAt`, many Topic `description` / `questionCount` values, and answer, follower and comment counts on questions listed in a Space or Topic feed. Answer views, upvotes, shares and comment counts are available.
- **Some answers come as previews.** Quora sometimes shows only the start of a long answer — most often on profiles and in Space feeds, occasionally on a question page. Those rows carry `isTextTruncated: true`; a later run of the question page usually gives the whole text.
- **Keyword search covers what web search has indexed.** Quora's own search is closed to signed-out visitors, so keyword search finds matching Quora pages through public web search. Very new pages may not show up yet, and results can differ between runs. Spaces are indexed sparsely, so a Space search usually returns only a few of them.
- **Runs take time.** Expect several seconds per page — a run of a few hundred rows takes minutes, not seconds.
- **Topics vs Spaces.** Topic feeds show less to signed-out visitors than Spaces; the Topic's own row is reliable, feed depth varies.
- **Contact details depend on the person.** Links come only from the person's Quora bio and e-mails only from their own website linked there; reference links such as encyclopedias, dictionaries or publishers are not visited. Many people link nothing — expect addresses for a minority of authors.

***

### FAQ

**Do I need to log in, add cookies or set anything up?**
No. Questions, answers, profiles, Spaces, Topics and search all work without an account, and the connection is already configured — add your links or phrases and start.

**Why are `viewCount` and `askedAt` empty on questions?**
Quora no longer shows question view counts or ask dates to signed-out visitors. Answer-level `viewCount` is unaffected.

**What does the optional `cookies` field do?**
It opens pages as your own signed-in Quora session, using cookies you export from your browser. Nothing described on this page needs it; it is provided as is, and your account is used at your own discretion.

**Can I pass usernames or slugs instead of full links?**
Yes — put bare slugs like `Adam-DAngelo` in `identifiers`; they are read according to `mode`. Full links work there too.

**How many answers will I get per question?**
The top answers Quora shows a signed-out visitor — usually about half a dozen.

**What happens if I start with an empty form?**
In Question mode the actor scrapes one example question so you can see the output format, and says so in the log.

**Can I get contact details for lead generation?**
Use `scrapeAuthorProfiles` (for answer authors) or Profile mode, together with `extractAuthorContacts`. Rows then carry `links[]` from the person's Quora bio, `emails[]` from the website linked there (each checked for a mail server), `isLead` and `leadScore`.

**Is this allowed?**
The actor collects **public** data only and uses no login. Scraping public pages is broadly permissible but may conflict with Quora's Terms of Service, and any personal data (author names, links, e-mails) must be used in line with GDPR/CCPA. Compliance is the operator's responsibility.

***

### Support & feedback

**Something went wrong?** Open an issue on the Actor's **Issues** tab and include the run ID and the input you used. I always do my best to find the cause, fix it and help you get the data you need.

**Missing a field or an option?** Issues are the right place for that too.

**If this Actor was useful to you, please leave a rating or a short review on its Store page.** It helps other people find it and keeps a small independent Actor visible.

# Actor input Schema

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

What to scrape. 'Question + answers' opens question pages and pulls their answers; 'Keyword search' finds Quora pages for your phrases; 'Profile' scrapes a user profile with their answers and posts; 'Space / Topic' scrapes a Space or Topic page with its feed. Links are recognised automatically, so a mixed list of URLs works in any mode; the mode also decides how bare identifiers are read.

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

Quora links: question, answer, profile, Space (name.quora.com; old quora.com/q/name links are converted), Topic (/topic/...), or a Quora search link (run as a keyword search). Each link's type is detected automatically, so a mixed list works. In the form just paste the links; in JSON this field takes objects — \[{"url": "https://www.quora.com/..."}]. For a plain list of strings use "Identifiers" below, which also accepts full URLs. If Question mode is started with no links, identifiers or search terms at all, one example question is scraped so you can see the output.

## `identifiers` (type: `array`):

Bare identifiers instead of full links, read according to the selected mode: a profile slug such as 'Adam-DAngelo', a question slug, or a Space name such as 'quorablog'. Full URLs pass through unchanged, so this is also the simplest way to give a plain list of links in JSON.

## `searchTerms` (type: `array`):

Phrases to search Quora for, one search per phrase. Every page found is scraped like a pasted link. Terms run in any mode, so clear this list if you only want your links.

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

Which kind of Quora page a keyword search returns. 'Questions' gives question pages together with their answers.

## `maxItems` (type: `integer`):

Maximum number of rows saved across all links and searches. Each row is billed, so this also caps the result charge. 0 = no limit.

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

Most answers kept per question page; on a profile, most answers and posts combined. Quora shows signed-out visitors only its top answers — usually about half a dozen — so a higher number cannot add more. 0 = all that Quora shows.

## `includeAnswers` (type: `boolean`):

Save answer rows. Turn off and a question page gives only the question row, a profile only the profile row.

## `scrapeAuthorProfiles` (type: `boolean`):

On question pages: open each answer author's profile once and save an extra 'author' row with their credential, follower, answer and view counts, the links in their bio and a lead score. Each author row needs its own page load and is billed as a profile.

## `extractAuthorContacts` (type: `boolean`):

With author enrichment, or in Profile mode: visit the person's own website linked in their Quora bio and collect the addresses it publishes for itself, each checked for a mail server. Reference links such as encyclopedias or dictionaries are skipped. Public data only. Billed as a separate contact event, and only when at least one address is found.

## `authorFilter` (type: `string`):

Keep only answers whose author name or profile slug contains this text (case-insensitive). Leave empty for all authors.

## `onlyNewItems` (type: `boolean`):

Skip anything an earlier run of this actor in your account already saved with this option on, so a scheduled run returns only new questions, answers and posts.

## `excludeEmptyFields` (type: `boolean`):

Leave out empty fields from each row for a tighter dataset.

## `cookies` (type: `array`):

Not needed — everything in this form works without an account. If you add cookies exported from your own signed-in Quora session, pages are opened as that session. Provided as is; your account is used at your own discretion. Array of {"name", "value"} objects.

## `monitorMode` (type: `boolean`):

Works like 'Only new items' and, after each run, also POSTs a short list of the new items (type, link, title, author) to the webhook URL below.

## `webhookUrl` (type: `string`):

Where monitor mode sends its list of new items.

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

Nothing to change here — the default is already set up for Quora and is used automatically.

## Actor input object example

```json
{
  "mode": "question",
  "startUrls": [],
  "identifiers": [],
  "searchTerms": [],
  "searchType": "question",
  "maxItems": 100,
  "maxAnswers": 20,
  "includeAnswers": true,
  "scrapeAuthorProfiles": false,
  "extractAuthorContacts": false,
  "authorFilter": "",
  "onlyNewItems": false,
  "excludeEmptyFields": false,
  "monitorMode": false,
  "webhookUrl": "",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

## `results` (type: `string`):

No description

## `runSummary` (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 = {
    "mode": "question",
    "searchType": "question",
    "maxItems": 100,
    "maxAnswers": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("brilliant_gum/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",
    "searchType": "question",
    "maxItems": 100,
    "maxAnswers": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("brilliant_gum/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",
  "searchType": "question",
  "maxItems": 100,
  "maxAnswers": 20
}' |
apify call brilliant_gum/quora-scraper --silent --output-dataset

```

## MCP server setup

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