# Quora Question, Answer & Profile Search Scraper (`dataspryva/quora-question-answer-and-profile-search-scraper`) Actor

Search Quora by keyword or scrape question, answer, profile, topic, Space, and post URLs directly, and get the text, author details, and engagement counts of each visibly accessible page, with clear status rows for anything blocked.

- **URL**: https://apify.com/dataspryva/quora-question-answer-and-profile-search-scraper.md
- **Developed by:** [Dataspryva](https://apify.com/dataspryva) (community)
- **Categories:** Social media, Lead generation, Automation
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.49 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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 Question, Answer & Profile Search Scraper

Find Quora questions by keyword, then export full answers, author profiles, and engagement data. You can also paste question, answer, profile, or topic URLs for a deterministic export that does not depend on search.

### How discovery works

Quora's own keyword search is login-gated, so this actor uses a public search index in front of Quora:

1. **Index discovery** finds Quora question or profile pages for your keywords.
2. **A relevance check** drops index hits whose title does not share a meaningful word with your query.
3. **Related-question expansion** opens the related questions Quora links from each question page. Quora exposes up to 70 per question, which is how one index result becomes a useful set.
4. **Page hydration** reads the public question, answer, profile, or topic page and builds the rows.

Search is best-effort: some narrow or unusual queries return no usable Quora question, and the run says so with a status row. A run that produces no real rows fails with a clear message instead of reporting success. Direct URLs and usernames always work without search.

### Modes

- **Search by keyword** — one or more phrases; questions, answers, and optional profile/author rows.
- **Scrape direct URLs** — question, answer, profile, or topic URLs, including language subdomains.
- **Discover authors** — collect answer authors from URLs or search results and enrich their public profiles.

### What each row contains

- **Question** — title, URL, question ID, topics, follower count, answer count, related questions, discovery query, and parent question when reached through expansion.
- **Answer** — full text (and optional HTML), answer URL and ID, upvotes, views, comments count, shares count, exact ISO creation time, AI label, related-answer provenance, and author details.
- **Profile / author** — name, profile URL, bio, credential, verified flag, followers, following, answer and question counts, content views, join date, location, employment, education, topics, and answer evidence.
- **Topic** — name, URL, topic ID, and follower count.
- **Search result** — an index card that matched the query: title, snippet when meaningful, URL, rank, type, and source.
- **Status** — a typed row when a page is blocked, removed, not found, or a query has no usable result.
- **Run manifest** — counts, discovery sources, proxy path, and per-input accounting.

Empty fields are omitted, never filled with null or placeholder values.

### Input reference

| Field | Type | Default | What it does |
|---|---|---|---|
| `mode` | select | `search` | Search, direct URLs, or author discovery. |
| `searchQueries` | array | `[]` | Keyword phrases used by search and author modes. |
| `searchTarget` | select | `questions` | Look for questions, profiles, or both. |
| `directUrls` | array | `[]` | Question, answer, profile, or topic URLs. |
| `usernames` | array | `[]` | Profile usernames or slugs. |
| `resultTypes` | array | `["question","answer","search_result"]` | Rows to save. |
| `includeAnswers` | boolean | `true` | Expand questions into answer rows. |
| `maxAnswersPerQuestion` | integer | `20` | Answers per question, including visible ones. |
| `expandRelatedQuestions` | boolean | `true` | Open related questions from each question page. |
| `maxRelatedQuestionsPerSeed` | integer | `20` | Related questions to open per seed. |
| `maxQuestionsPerQuery` | integer | `50` | Question-row cap per search query. |
| `includeAuthorProfiles` | boolean | `true` | Enrich author rows with profile statistics. |
| `maxAuthors` | integer | `100` | Maximum author rows. |
| `minAnswerUpvotes` | integer | `0` | Minimum explicit upvote count. |
| `filterAiAnswers` | select | `include` | Include, exclude, or keep only AI-labelled answers. |
| `answerSortOrder` | select | `observed` | Quora order, most upvoted, or newest. |
| `onlyUnanswered` | boolean | `false` | Keep only questions with an explicit zero answer count. |
| `includeProfileSensitiveFields` | boolean | `true` | Include location, employment, education, and join date. |
| `includeSocialLinks` | boolean | `true` | Include website and social links. |
| `includeAnswerHtml` | boolean | `true` | Add rendered answer HTML beside plain text. |
| `maxItems` | integer | `200` | Maximum real rows; status and manifest do not count. |
| `includeFieldEvidence` | boolean | `true` | Include field provenance maps. |

### Example inputs

Search questions and answers:

```json
{
  "mode": "search",
  "searchQueries": ["best productivity apps", "healthy meal prep"],
  "searchTarget": "questions",
  "expandRelatedQuestions": true,
  "maxRelatedQuestionsPerSeed": 20,
  "maxQuestionsPerQuery": 30,
  "maxAnswersPerQuestion": 5,
  "maxItems": 100
}
```

Scrape a specific question:

```json
{
  "mode": "urls",
  "directUrls": ["https://www.quora.com/What-is-Python-primarily-used-for"],
  "resultTypes": ["question", "answer"],
  "maxAnswersPerQuestion": 20
}
```

Find profiles by keyword:

```json
{
  "mode": "search",
  "searchQueries": ["Naval Ravikant", "Sam Altman"],
  "searchTarget": "profiles",
  "resultTypes": ["profile", "author"],
  "maxItems": 20
}
```

### Use cases

- Content and market research on public discussions
- Building a question/answer corpus for analysis
- Finding subject-matter authors and their public statistics
- Monitoring how a topic's questions and answers change over time

### FAQ

**Do I need to log in or provide cookies?**
No. The actor never asks for cookies and only reads public pages.

**Why does a keyword search sometimes return a status row instead of questions?**
The public index may have no relevant Quora question for that phrase, or its first hit may be unrelated. The actor refuses to hydrate an off-topic seed and reports the query instead of returning random questions.

**Why is native Quora search not used?**
Quora's `/search?q=` page is login-gated for anonymous visitors and is disallowed by Quora's robots rules. The actor uses a public index and related questions instead.

**How many questions can one keyword produce?**
One index hit can expand to up to 70 related questions, bounded by Maximum Questions per Query. A query with no usable index hit produces none.

**Why is profile search less complete than question search?**
Search engines index far fewer Quora profiles than questions. Direct usernames and profile URLs are exact; keyword profile search is best-effort.

**Why are some profile fields missing?**
Quora only shows location, employment, education, and credentials on some profiles. Missing values are omitted rather than guessed.

**Can I get comments?**
Comment bodies are not part of the public server-rendered page. Answer rows include the comment count, not the comment text.

**Can I get a question's creation date or exact view count?**
Those values appear only on a Quora log page that its robots rules disallow, so the actor does not fetch it. Answer creation times are exact.

**Does the actor use a proxy?**
It connects automatically and falls back to Apify Proxy only when Quora blocks the direct connection. There is no proxy field to configure.

**Is this affiliated with Quora?**
No. This is an independent, third-party actor that reads publicly visible pages. Users are responsible for how they use the data.

# Actor input Schema

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

Search discovers questions through the DuckDuckGo index and Quora related questions. URLs is deterministic and does not depend on search.

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

Two to four word phrases work best. Each query finds at most a couple of question seeds, then related questions expand the result.

## `searchTarget` (type: `string`):

Choose whether keyword discovery looks for question pages, profile pages, or both. Profile search is best-effort because search engines index few Quora profiles.

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

Question, answer, profile, or topic URLs. Language subdomains are accepted. Comma-separated or one URL per line.

## `usernames` (type: `array`):

Quora profile usernames or slugs, with or without @ or a trailing slash. Each is normalised to a profile URL.

## `resultTypes` (type: `array`):

Which rows to save. Status and run-manifest rows are always emitted so blocked or empty sources stay visible.

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

Expand question pages into answer rows. Turn off to keep question rows only.

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

Answers to collect from each question, including the 3-5 already visible on the page. Zero means no answers.

## `expandRelatedQuestions` (type: `boolean`):

Open related questions linked from each question page. Quora exposes up to 70, which is how keyword search reaches more than its first result.

## `maxRelatedQuestionsPerSeed` (type: `integer`):

How many related questions to open from each question page. Zero lists the links without opening them.

## `maxQuestionsPerQuery` (type: `integer`):

Hard cap on question rows for each search query, including seed and related questions.

## `includeAuthorProfiles` (type: `boolean`):

Open each discovered author's profile to add follower, answer, question, view, and join-date fields. Turn off to keep author rows from answer evidence only.

## `maxAuthors` (type: `integer`):

Maximum unique author rows to emit when author is included in Result Types.

## `minAnswerUpvotes` (type: `integer`):

Keep only answers with an explicit upvote count at or above this value. Answers with unknown upvotes are excluded when this is positive.

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

Include all answers, drop answers Quora explicitly labels as AI, or keep only those labelled answers.

## `answerSortOrder` (type: `string`):

Keep Quora's order, sort by explicit upvotes, or sort by the answer creation timestamp.

## `onlyUnanswered` (type: `boolean`):

Keep only questions whose visible answer count is exactly zero. Questions with an unknown count are excluded.

## `includeProfileSensitiveFields` (type: `boolean`):

Include location, employment, education, and join date on profile and author rows when Quora shows them.

## `includeSocialLinks` (type: `boolean`):

Include website and social links from a profile's public bio when present.

## `includeAnswerHtml` (type: `boolean`):

Include a rendered HTML version of each answer beside its plain text. Turn off to reduce dataset size.

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

Maximum question, answer, profile, author, topic, and search-result rows across the run. Status and manifest rows do not count.

## `includeFieldEvidence` (type: `boolean`):

Include field_sources and fields_present provenance maps on each row.

## Actor input object example

```json
{
  "mode": "urls",
  "searchQueries": [],
  "searchTarget": "questions",
  "directUrls": [
    "https://www.quora.com/What-is-Python-primarily-used-for"
  ],
  "usernames": [],
  "resultTypes": [
    "question",
    "answer"
  ],
  "includeAnswers": true,
  "maxAnswersPerQuestion": 2,
  "expandRelatedQuestions": false,
  "maxRelatedQuestionsPerSeed": 0,
  "maxQuestionsPerQuery": 1,
  "includeAuthorProfiles": true,
  "maxAuthors": 1,
  "minAnswerUpvotes": 0,
  "filterAiAnswers": "include",
  "answerSortOrder": "observed",
  "onlyUnanswered": false,
  "includeProfileSensitiveFields": true,
  "includeSocialLinks": true,
  "includeAnswerHtml": false,
  "maxItems": 3,
  "includeFieldEvidence": true
}
```

# Actor output Schema

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

Dataset containing question, answer, profile, author, topic, search_result, status, and run_manifest rows.

# 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": "urls",
    "searchQueries": [],
    "searchTarget": "questions",
    "directUrls": [
        "https://www.quora.com/What-is-Python-primarily-used-for"
    ],
    "usernames": [],
    "resultTypes": [
        "question",
        "answer"
    ],
    "includeAnswers": true,
    "maxAnswersPerQuestion": 2,
    "expandRelatedQuestions": false,
    "maxRelatedQuestionsPerSeed": 0,
    "maxQuestionsPerQuery": 1,
    "includeAuthorProfiles": true,
    "maxAuthors": 1,
    "minAnswerUpvotes": 0,
    "filterAiAnswers": "include",
    "answerSortOrder": "observed",
    "onlyUnanswered": false,
    "includeProfileSensitiveFields": true,
    "includeSocialLinks": true,
    "includeAnswerHtml": false,
    "maxItems": 3,
    "includeFieldEvidence": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("dataspryva/quora-question-answer-and-profile-search-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": "urls",
    "searchQueries": [],
    "searchTarget": "questions",
    "directUrls": ["https://www.quora.com/What-is-Python-primarily-used-for"],
    "usernames": [],
    "resultTypes": [
        "question",
        "answer",
    ],
    "includeAnswers": True,
    "maxAnswersPerQuestion": 2,
    "expandRelatedQuestions": False,
    "maxRelatedQuestionsPerSeed": 0,
    "maxQuestionsPerQuery": 1,
    "includeAuthorProfiles": True,
    "maxAuthors": 1,
    "minAnswerUpvotes": 0,
    "filterAiAnswers": "include",
    "answerSortOrder": "observed",
    "onlyUnanswered": False,
    "includeProfileSensitiveFields": True,
    "includeSocialLinks": True,
    "includeAnswerHtml": False,
    "maxItems": 3,
    "includeFieldEvidence": True,
}

# Run the Actor and wait for it to finish
run = client.actor("dataspryva/quora-question-answer-and-profile-search-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": "urls",
  "searchQueries": [],
  "searchTarget": "questions",
  "directUrls": [
    "https://www.quora.com/What-is-Python-primarily-used-for"
  ],
  "usernames": [],
  "resultTypes": [
    "question",
    "answer"
  ],
  "includeAnswers": true,
  "maxAnswersPerQuestion": 2,
  "expandRelatedQuestions": false,
  "maxRelatedQuestionsPerSeed": 0,
  "maxQuestionsPerQuery": 1,
  "includeAuthorProfiles": true,
  "maxAuthors": 1,
  "minAnswerUpvotes": 0,
  "filterAiAnswers": "include",
  "answerSortOrder": "observed",
  "onlyUnanswered": false,
  "includeProfileSensitiveFields": true,
  "includeSocialLinks": true,
  "includeAnswerHtml": false,
  "maxItems": 3,
  "includeFieldEvidence": true
}' |
apify call dataspryva/quora-question-answer-and-profile-search-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,dataspryva/quora-question-answer-and-profile-search-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/4f1nWGGi2uy4RE0qo/builds/4Ofo0BFs3PM3I87Iz/openapi.json