# Quora Search Scraper — Fresh & Trending Question Monitor (`simpleapi/quora-search-scraper`) Actor

🔍 Quora Search Scraper helps you extract answers, questions, and author data from Quora search results. 🚀 Perfect for market research, lead gen, and content insights—fast, reliable, and easy to use. 📈 Get actionable data in minutes!

- **URL**: https://apify.com/simpleapi/quora-search-scraper.md
- **Developed by:** [SimpleAPI](https://apify.com/simpleapi) (community)
- **Categories:** Lead generation, Automation, Developer tools
- **Stats:** 4 total users, 3 monthly users, 96.7% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-usage

## 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 Trend Monitor — Fresh and Trending Questions

Quora Search Scraper — Fresh & Trending Question Monitor turns a keyword search or direct URL list into a filtered, sorted feed of recently-active Quora content, with every row carrying an absolute creation date, an age-in-days figure, and a freshness flag — plus optional delta tracking that flags which questions are new since your last scheduled run. It's built for trend researchers and content teams who need to know what's newly active on Quora right now, not just what matches a keyword, community managers running recurring monitoring on a topic, and market researchers who want AI-generated trend labels grouping fresh questions into themes at a glance. No Quora login is required. Every section below documents an input, an output field, or exactly how the freshness window and delta tracking work.

### What is Quora Search Scraper — Fresh & Trending Question Monitor?

This Actor is a superset of a plain Quora search scraper: keyword search (via DuckDuckGo discovery) and direct-URL scraping both still work exactly as a base scraper would, with a real recency filter, topic filter, sort order, and cross-run new-question tracking layered on top.

Key capabilities, read from the source:

- **Two-layer freshness filtering, not just a discovery-time filter.** `timeFilter` is applied both at discovery (DuckDuckGo's own date-range parameter) and again as a genuine post-fetch check against each answer's real `creationTime` — so a question can't slip through just because DuckDuckGo's index metadata was stale.
- **Question-level freshness inherited from its newest answer.** When a question itself has no reliable timestamp, `_apply_filters_and_delta()` falls back to the age of its most recently-posted answer to decide whether the question counts as fresh — an undated question is marked `is_fresh: null` rather than guessed either way.
- **Real topic filtering, not a keyword re-search.** `topicsFilter` matches case-insensitively against each question's actual Quora topic tags (`_topic_match()`), keeping only questions genuinely tagged with your chosen topics — non-question content (profiles, spaces) passes through untouched since topic tagging doesn't apply to them.
- **Persistent new-question tracking across scheduled runs.** `trackNewQuestions` stores each seen question's URL and first-seen timestamp in a named key-value store; the very first run has nothing to diff against and is explicitly logged as a baseline-seeding run (`is_new: null`), with only subsequent runs producing a real `is_new: true/false`.
- **Optional AI trend clustering, off by default.** `aiEnhancement` groups the collected fresh questions into short `trend_cluster` labels via a chosen LLM provider — this only runs over questions already collected, so it never affects which content is scraped, only how it's labeled afterward.
- **Global post-collection sorting.** `sortBy` (`recent`, `upvotes`, or `relevance`) is applied once across the entire collected buffer at the end of the run, not per-search-batch, so the final feed is genuinely ordered across all your keywords and URLs combined.

### What data can I extract with Quora Search Scraper — Fresh & Trending Question Monitor?

Every field below is read directly from `_apply_filters_and_delta()` and the row assembly in `main()` in `src/main.py` — dedicated dataset views (`trending`, `overview`, `answers`, `questions`, `profiles`, `topics`, `spaces`) group these by content type.

#### Freshness and trend fields (new in this variant)

| Field | Example Value | Notes |
| --- | --- | --- |
| `created_at` | `2026-07-20T10:15:00Z` | Absolute ISO timestamp — for a question, inherited from its newest answer |
| `age_days` | `6` | Days since `created_at` |
| `is_fresh` | `true` | Whether the row falls inside your `timeFilter` window; `null` when the row is undated and can't be proven stale |
| `is_new` | `true` | Whether this question wasn't in the prior run's seen-store; `null` on the first (baseline) run |
| `first_seen_at` | `2026-07-14T09:00:00Z` | When this question was first observed across scheduled runs |
| `trend_cluster` | `"AI coding tools"` | Short theme label; only populated when `aiEnhancement` is on |

#### Base question, answer, profile, topic, and space fields

| Field | Example Value | Content Type |
| --- | --- | --- |
| `title` / `answer_count` / `follow_count` / `topics` | question fields | `question` |
| `answer_text` / `author_name` / `author_credentials` / `upvotes` / `comments_count` / `shares_count` / `is_ai_answer` | answer fields | `answer` |
| `name` / `bio` / `credentials` / `follower_count` / `following_count` / `answer_count` / `total_views` | profile fields | `profile` |
| `name` / `description` / `follower_count` / `question_count` | topic fields | `topic` |
| `name` / `description` / `follower_count` / `post_count` / `contributor_count` | space fields | `space` |

### Why not build this yourself?

Quora has no public API, and there's no documented endpoint for "recently active questions" at all — the only path to a real freshness signal is decoding each answer's actual creation timestamp from Quora's embedded GraphQL data and comparing it against a window yourself, since DuckDuckGo's own date filter (the discovery mechanism) is index-time, not content-time, and its finest bucket is a full day. Reliable cross-run "what's new" tracking additionally requires persisting state between runs and diffing against it correctly — including handling the first run's cold-start case honestly (returning everything as baseline rather than falsely flagging it all as "new"), which is easy to get subtly wrong.

### How to use data extracted from Quora Search Scraper — Fresh & Trending Question Monitor?

#### Trend and content research

Search a broad topic keyword with `timeFilter: "past_week"` and `sortBy: "recent"` to see what's genuinely newly active on Quora in that space right now, rather than a keyword match regardless of age.

#### Recurring community monitoring

Schedule this Actor with `trackNewQuestions` on against your niche's core topics — after the first baseline run, every subsequent run flags exactly which questions are new since the last check, ideal for a monitoring dashboard or alert feed.

#### Market research with theme grouping

Turn on `aiEnhancement` to get fresh questions automatically grouped into `trend_cluster` labels — useful for spotting emerging sub-themes within a broader topic without manually reading every question title.

#### AI agents and monitoring pipelines

Because `is_fresh`/`is_new`/`age_days` are all computed server-side from real timestamps, an agent can trust these fields directly for alerting logic without re-deriving freshness itself.

### 🔼 Input sample

| Parameter | Required | Type | Description | Example Value |
| --- | --- | --- | --- | --- |
| `searchQueries` | No | array | Keywords to search on Quora via DuckDuckGo discovery. | `["python programming"]` |
| `directUrls` | No | array | Direct Quora URLs — questions, profiles, topics, or spaces. | `[]` |
| `maxResults` | No | integer (1–50000) | Total rows to collect after filtering, across all keywords/URLs combined. Default `10`. | `100` |
| `timeFilter` | No | string enum | `all_time`, `past_day`, `past_week`, `past_month`, `past_year`. Default `"all_time"`. | `"past_week"` |
| `topicsFilter` | No | array | Only keep questions tagged with these Quora topics (case-insensitive). | `["Programming Languages"]` |
| `sortBy` | No | string enum | `recent`, `upvotes`, or `relevance`. Default `"recent"`. | `"recent"` |
| `trackNewQuestions` | No | boolean | Flag questions new since the last scheduled run. Default `false`. | `true` |
| `aiEnhancement` | No | boolean | Group fresh questions into `trend_cluster` labels. Default `false`. | `false` |
| `aiModel` | No | string enum | Model/provider for clustering (Claude, GPT, Gemini, Grok, DeepSeek, Sonar, Mistral variants). Default `"claude-haiku-4-5"`. | `"claude-haiku-4-5"` |
| `aiApiKey` | No | string (secret) | Provider API key; falls back to the matching environment variable. | `"sk-..."` |
| `proxyConfiguration` | No | object | Starts direct, escalates to datacenter then residential automatically on a block. | `{"useApifyProxy": true}` |

```json
{
  "searchQueries": ["python programming"],
  "timeFilter": "past_week",
  "sortBy": "recent",
  "trackNewQuestions": true,
  "maxResults": 100
}
```

**Common pitfall:** the schema notes that `"past_hour"` isn't a real option — DuckDuckGo's finest date bucket is one day, so a `past_hour` value is silently normalized to `past_day` internally. Don't expect hour-level freshness precision from this Actor's discovery layer.

### 🔽 Output sample

Output is one JSON row per question, answer, profile, topic, or space, pushed to the run's default dataset and charged as one `row_result` event per row.

```json
{
  "content_type": "question",
  "title": "What are the best new Python libraries for data science in 2026?",
  "url": "https://www.quora.com/What-are-the-best-new-Python-libraries-for-data-science-in-2026",
  "answer_count": 12,
  "follow_count": 340,
  "topics": ["Python (programming language)", "Data Science"],
  "created_at": "2026-07-20T10:15:00Z",
  "age_days": 6,
  "is_fresh": true,
  "is_new": true,
  "first_seen_at": "2026-07-20T10:15:00Z",
  "trend_cluster": null,
  "source_query": "python programming",
  "scrape_timestamp": "2026-07-26T09:00:00Z"
}
```

### How do you filter and target fresh and trending content?

**Freshness window drives both cost and relevance.** A narrow `timeFilter` (`past_day`/`past_week`) both speeds up the run (fewer stale results to filter after fetch) and focuses the output on genuinely current activity — start narrow and widen only if a niche topic doesn't have enough recent volume.

**Combine topic and freshness filters for a focused trend feed.** `topicsFilter` plus `timeFilter` together is the core "trend monitor" pattern — scoped to your niche's real Quora topic tags, restricted to a recency window, sorted by `recent`.

**Delta tracking needs a consistent schedule.** `trackNewQuestions` only produces meaningful `is_new` values on the second and later runs against the same query/URL set — running with different `searchQueries` each time won't build a useful history, since the seen-store is keyed by question URL, not by search term.

Three real examples:

```json
{ "searchQueries": ["startup funding"], "timeFilter": "past_week", "sortBy": "recent", "trackNewQuestions": true }
```

Recurring weekly trend monitor with new-question flagging.

```json
{ "searchQueries": ["ai tools"], "topicsFilter": ["Artificial Intelligence"], "timeFilter": "past_month", "aiEnhancement": true }
```

Topic-scoped trend feed with AI clustering into themes.

```json
{ "directUrls": ["https://www.quora.com/some-question"], "timeFilter": "all_time" }
```

Single-question deep scrape with no freshness restriction.

### ▶️ Want to try other scrapers?

| Scraper | What it extracts |
| --- | --- |
| Quora Scraper with Human Answer Quality Score | Quality-ranked, AI-filtered Q\&A data |
| Google News Scraper | Headlines, publisher domain and links |
| X/Twitter Trends Scraper by City | Trending topics across cities |
| Reddit Trends Scraper with Author Contact Leads | Trending Reddit posts with contact leads |

### How to extract Quora trend data programmatically

This Actor runs as a standard Apify Actor call — one API call in, structured JSON dataset out, using your Apify API token.

#### Python example

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_API_TOKEN>")
run = client.actor("<YOUR_USERNAME>/quora-search-scraper-fresh-trending-question-monitor").call(run_input={
    "searchQueries": ["python programming"],
    "timeFilter": "past_week",
    "trackNewQuestions": True,
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    if item.get("content_type") == "question":
        print(item["title"], item["age_days"], item.get("is_new"))
```

#### Export to spreadsheets or CRM

Every dataset supports one-click CSV/Excel export from the Apify Console, plus dedicated dataset views (`trending`, `questions`, `answers`, `profiles`, `topics`, `spaces`) for exporting one content type at a time.

### Is it legal to scrape Quora?

Scraping publicly visible Quora questions, answers, and profiles is generally lawful, since this data is published for anyone to view without logging in — the underlying legal question was tested directly in *hiQ Labs v. LinkedIn* (9th Cir.), which held that scraping public, non-password-protected data does not violate the U.S. Computer Fraud and Abuse Act. Author names and profile bios can constitute personal data under GDPR/CCPA when tied to an identifiable individual, so treat that subset accordingly if you store or reuse it at scale, and consult legal counsel for commercial applications.

### ❓ FAQ

#### How precise is the freshness filter?

DuckDuckGo's discovery-time date filter buckets by day at its finest, but the post-fetch filter checks each answer's real `creationTime` down to the timestamp, so `age_days` and `is_fresh` are accurate even though discovery itself can't target anything finer than a day.

#### What happens on the very first scheduled run with trackNewQuestions on?

It's treated explicitly as a baseline-seeding run — every question gets `is_new: null` (not `true`), since there's no prior snapshot to compare against. Only the second and later runs against the same seen-store produce real `true`/`false` values.

#### Does topicsFilter re-search Quora for those topics?

No — it filters the already-discovered questions by matching their real Quora topic tags against your filter terms, case-insensitively and substring-either-way. It doesn't issue additional search queries.

#### Can a question be marked fresh even with no timestamp of its own?

A question with no reliable timestamp inherits freshness from its newest answer's age; if there's no dated answer either, `is_fresh` is `null` rather than guessed, since the Actor can't prove the question is stale without any real date to check.

#### Do I need an AI API key for the trend monitoring features?

No — freshness filtering, topic filtering, sorting, and new-question tracking are all core features requiring no AI or API key. `aiEnhancement` (trend-cluster labels) is the only feature that needs a provider API key, and it's off by default.

#### How does this compare to other Quora monitoring scrapers?

As observed on the Apify Store on 2026-07-26, `crawlerbros/quora-search-scraper` covers keyword-based Quora search but doesn't document a real freshness window, topic filtering, or cross-run new-question tracking — those trend-monitoring features are specific to this Actor.

#### Does this work with AI agent frameworks?

Yes — call it as a standard HTTP endpoint via the Apify API from any agent framework capable of making an API call; there's no MCP-specific integration for this Actor.

### Conclusion

Quora Search Scraper — Fresh & Trending Question Monitor turns a keyword search into a genuine trend feed — real freshness filtering backed by actual timestamps, topic-scoped results, and cross-run new-question tracking for recurring monitoring. It fits trend research, community monitoring, and any workflow that needs to know what's newly active, not just what matches. Start a run from the Apify Console or the Apify API with your target keywords to get your first trend-scoped export.

# Actor input Schema

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

Keywords to search on Quora. Each keyword discovers relevant Quora question URLs (via DuckDuckGo) and scrapes them. No Quora login needed. ✨ Example: "what is python used for".

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

Paste any Quora URLs directly — questions ❓, profiles 👤, topics 🏷️ or spaces 🪐. Supports bulk input (one per line).

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

Total number of result rows to collect after filtering — across all keywords and URLs combined. Example: 60, 200 or 500. ✅

## `timeFilter` (type: `string`):

Restrict to recently-active content instead of all-time results. Applied twice: as the DuckDuckGo date-range at discovery AND as a real post-fetch filter on each answer's creation date. Note: the finest bucket is one DAY (no hourly). Example: past\_week keeps content whose newest answer is ≤ 7 days old. Default: all\_time.

## `topicsFilter` (type: `array`):

Only keep questions tagged with these Quora topics (matched against each question's topics list, case-insensitive). Leave empty to keep all. ✨ Example: \["Programming Languages", "Digital Marketing"].

## `sortBy` (type: `string`):

Order the final feed. recent = newest activity first (pair with the time filter for a trend feed), upvotes = highest engagement first, relevance = search/discovery order. Sorting is applied post-collection. Default: recent.

## `trackNewQuestions` (type: `boolean`):

For scheduled runs: remember question URLs in a persistent store and set is\_new=true + first\_seen\_at on questions not seen before. The first run seeds the store (is\_new=null). Default: off.

## `aiEnhancement` (type: `boolean`):

Group the collected fresh questions into short trend-cluster labels using the model below. Requires an API key. Default: off.

## `aiModel` (type: `string`):

Provider auto-detected from the name: claude-*=Anthropic, gpt-*/o1/o3=OpenAI, gemini-*=Google, grok-*=xAI, deepseek-*=DeepSeek, sonar*=Perplexity, mistral-\*=Mistral. Cheaper mini/flash/haiku/lite models are recommended for clustering.

## `aiApiKey` (type: `string`):

API key for the chosen provider. Left blank, the matching env var is used (ANTHROPIC\_API\_KEY / OPENAI\_API\_KEY / GOOGLE\_API\_KEY / XAI\_API\_KEY / DEEPSEEK\_API\_KEY / PERPLEXITY\_API\_KEY / MISTRAL\_API\_KEY). Only used when AI clustering is on.

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

Optional Apify Proxy configuration used as the mid-tier (datacenter) network. Residential is applied automatically as the final fallback.

## Actor input object example

```json
{
  "searchQueries": [
    "python programming"
  ],
  "directUrls": [],
  "maxResults": 10,
  "timeFilter": "all_time",
  "topicsFilter": [],
  "sortBy": "recent",
  "trackNewQuestions": false,
  "aiEnhancement": false,
  "aiModel": "claude-haiku-4-5",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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 = {
    "searchQueries": [
        "python programming"
    ],
    "directUrls": [],
    "maxResults": 10,
    "topicsFilter": [],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("simpleapi/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 = {
    "searchQueries": ["python programming"],
    "directUrls": [],
    "maxResults": 10,
    "topicsFilter": [],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("simpleapi/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 '{
  "searchQueries": [
    "python programming"
  ],
  "directUrls": [],
  "maxResults": 10,
  "topicsFilter": [],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call simpleapi/quora-search-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/0ld5aGjubL7YJycMC/builds/AttDqMbCPFTCR1hpf/openapi.json