# Quora Search Scraper (`maximedupre/quora-search-scraper`) Actor

Find public Quora question pages from search terms or direct URLs. Export titles, URLs, visible topics, answer preview text, related-count hints, and scrape timestamps.

- **URL**: https://apify.com/maximedupre/quora-search-scraper.md
- **Developed by:** [Maxime Dupré](https://apify.com/maximedupre) (community)
- **Categories:** Social media
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 quora question rows

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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 Search Scraper

Quora Search Scraper helps you find and scrape public [Quora](https://www.quora.com/) question pages from search terms or direct Quora question URLs. Enter a topic such as `python programming`, `machine learning careers`, or any public Quora question URL, and the Actor saves structured question rows you can export, schedule, or use through the Apify API.

The Actor is built for public research workflows: content research, question discovery, SEO research, audience research, market research, and finding real questions people ask around a topic. It returns source URLs, question titles, visible topic labels, related-question counts when shown, first-answer preview text, and scrape metadata.

This is not a logged-in Quora account automation tool. It only works with public Quora question pages that can be opened without a Quora account. Private profiles, restricted answers, native logged-in Quora search results, and Quora+ paywalled content are not accessible.

### What This Quora Scraper Does

Use this Actor when you need public Quora question data without manually searching, opening pages, copying URLs, and collecting question text by hand.

For each search term, the Actor discovers indexed public Quora question URLs, opens the matching question pages, and saves one dataset row per scraped question. You can also skip discovery and paste direct Quora question URLs when you already know which pages you want.

Good use cases include:

- Finding public Quora questions around a keyword, niche, product, or audience.
- Collecting question URLs and topics for SEO briefs or content calendars.
- Researching how people phrase problems, objections, and buying questions.
- Building a small dataset of public Quora questions for analysis.
- Monitoring new research topics by scheduling repeat Apify runs.

### What Data You Get

Each saved dataset item is one public Quora question page. Rows include:

- `query` - search term that discovered the question, or `null` for direct URL runs.
- `sourceTarget` - original search term or URL you entered.
- `sourceTargetType` - `query` or `url`.
- `discoveryRank` - rank in the discovered public question URL list.
- `title` - Quora question title.
- `url` - canonical public Quora question URL.
- `questionSlug` - Quora question slug from the URL.
- `topics` - visible topic labels from the question page.
- `allRelatedCount` - visible "All related" count when Quora displays it.
- `answerPreview` - preview text from the first visible public answer block.
- `answerAuthorName` - best-effort visible name near the first answer.
- `scrapeStatus` - scrape status for the page.
- `scrapedAt` - UTC timestamp when the row was saved.

### How To Run It

1. Open the Actor input.
2. Add one or more search terms, such as `python programming` or `machine learning careers`.
3. Optionally paste public Quora question URLs in the same field.
4. Set the question limit.
5. Run the Actor and open the dataset.

The default input is small enough for a quick first run. For larger research jobs, raise the question limit and add several related search terms.

### Input

```json
{
  "targets": ["python programming", "machine learning careers"],
  "maxResults": 25,
  "maxDiscoveryResultsPerQuery": 20,
  "deduplicateQuestions": true
}
````

You can also scrape direct Quora question URLs:

```json
{
  "targets": ["https://www.quora.com/How-do-I-learn-Python"],
  "maxResults": 1
}
```

### Output Example

```json
{
  "query": "machine learning careers",
  "sourceTarget": "machine learning careers",
  "sourceTargetType": "query",
  "discoveryRank": 2,
  "title": "What are the possible careers in machine learning?",
  "url": "https://www.quora.com/What-are-the-possible-careers-in-machine-learning",
  "questionSlug": "What-are-the-possible-careers-in-machine-learning",
  "topics": ["Machine Learning", "Data Science"],
  "allRelatedCount": 66,
  "answerPreview": "Machine Learning is a field with many opportunities for careers...",
  "answerAuthorName": "Harsh Gupta",
  "scrapeStatus": "scraped",
  "scrapedAt": "2026-05-21T22:31:21.766Z"
}
```

### Pricing

This Actor uses pay-per-event pricing. A small actor-start charge applies when a run starts, and each saved public Quora question row is charged as a `quora-question-row` event. You only pay row events for question rows saved to the dataset.

### Limits And Caveats

Quora Search Scraper works with public Quora question pages. It does not log in to Quora, bypass private access, scrape Quora+ paywalled content, or return restricted answers. If a page is not publicly visible, it will not be saved as a scraped question row.

Keyword mode discovers public question URLs from indexed web results. It is designed to find relevant public question pages, not to reproduce Quora's logged-in native search experience exactly.

Output fields depend on what is visible on each public question page. Some pages may not show an answer preview, author name, topic list, or related-question count.

### FAQ

#### Can I scrape private Quora profiles or restricted answers?

No. The Actor only saves public Quora question pages that can be opened without a Quora account. Private profiles, restricted answers, logged-in-only results, and Quora+ paywalled content are not accessible.

#### Can I use direct Quora URLs?

Yes. Paste public Quora question URLs into the same input field as search terms. Direct URLs are useful when you already have a list of questions and want structured output rows.

#### Does this use Quora's logged-in search?

No. Search-term mode discovers indexed public Quora question URLs and then scrapes the public question pages directly. This keeps the Actor focused on public pages and avoids asking for Quora cookies or account credentials.

#### Can I export the results?

Yes. Apify datasets can be exported as JSON, CSV, Excel, XML, RSS, or HTML, and you can access results through the Apify API, webhooks, integrations, or scheduled runs.

# Actor input Schema

## `targets` (type: `array`):

Enter topics such as python programming or machine learning careers, or paste public Quora question URLs. You can mix search terms and direct URLs in one run.

## `maxResults` (type: `integer`):

Maximum public Quora question rows to save across all search terms and direct URLs.

## `maxDiscoveryResultsPerQuery` (type: `integer`):

Maximum indexed public Quora question URLs to collect from each search term before opening the pages.

## `deduplicateQuestions` (type: `boolean`):

Save only one row when multiple search terms find the same public Quora question URL.

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

🌐 Apify Proxy settings for public search discovery and Quora page requests. The default works for normal runs; override only when you need a specific proxy group.

## Actor input object example

```json
{
  "targets": [
    "python programming"
  ],
  "maxResults": 50,
  "maxDiscoveryResultsPerQuery": 20,
  "deduplicateQuestions": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

Open the dataset with public Quora question rows ready for export or API access.

# 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 = {
    "targets": [
        "python programming"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("maximedupre/quora-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 = { "targets": ["python programming"] }

# Run the Actor and wait for it to finish
run = client.actor("maximedupre/quora-search-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "targets": [
    "python programming"
  ]
}' |
apify call maximedupre/quora-search-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=maximedupre/quora-search-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Quora Search Scraper",
        "description": "Find public Quora question pages from search terms or direct URLs. Export titles, URLs, visible topics, answer preview text, related-count hints, and scrape timestamps.",
        "version": "0.0",
        "x-build-id": "jBR5lbYhqzmS3d4Ef"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/maximedupre~quora-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-maximedupre-quora-search-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/maximedupre~quora-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-maximedupre-quora-search-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/maximedupre~quora-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-maximedupre-quora-search-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "targets"
                ],
                "properties": {
                    "targets": {
                        "title": "Search terms or URLs",
                        "minItems": 1,
                        "type": "array",
                        "description": "Enter topics such as python programming or machine learning careers, or paste public Quora question URLs. You can mix search terms and direct URLs in one run.",
                        "items": {
                            "type": "string",
                            "minLength": 1
                        }
                    },
                    "maxResults": {
                        "title": "Question limit",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum public Quora question rows to save across all search terms and direct URLs.",
                        "default": 50
                    },
                    "maxDiscoveryResultsPerQuery": {
                        "title": "Discovery per search term",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Maximum indexed public Quora question URLs to collect from each search term before opening the pages.",
                        "default": 20
                    },
                    "deduplicateQuestions": {
                        "title": "Deduplicate questions?",
                        "type": "boolean",
                        "description": "Save only one row when multiple search terms find the same public Quora question URL.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "🌐 Apify Proxy settings for public search discovery and Quora page requests. The default works for normal runs; override only when you need a specific proxy group.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```