# Quora Monitor (`crawlerbros/quora-monitor-scraper`) Actor

Entity-agnostic Quora change monitoring (question, answer, profile, topic, or post) plus bounded Space metadata, feed, and contributor monitoring, with stateful diff evidence.

- **URL**: https://apify.com/crawlerbros/quora-monitor-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:**
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 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?

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 Monitor

Watch public Quora questions, answers, profiles, Topics, Spaces, posts, and visible feeds across scheduled runs. The actor compares each successful observation with its saved history and reports what is new, changed, or unchanged without turning a blocked page into a false deletion.

### What this actor does

- Watches several public Quora pages or search phrases in one run.
- Tracks visible page text, answer counts, authors, Topics, media, links, Space settings, rules, and feed items.
- Supports all, posts, questions, top, unanswered, about, and rules Space-feed views.
- Returns new, changed, and unchanged events with either a summary or before/after field values.
- Keeps common event and content values at the top level and less-common observations under `details`.

### Input

| Field | Type | Default | Description |
|---|---|---:|---|
| `directUrls` | list of URLs | one public question URL | Public Quora pages to watch. |
| `searchQueries` | list of text | none | Phrases whose public Quora discovery results should be watched. |
| `scrapeDepth` | choice | `detail` | `overview` for a lighter check; `detail` for visible feed and page details. |
| `maxResults` | number | `100` | Maximum watched sources. |
| `maxResultsPerSource` | number | `0` | Maximum observations per source; `0` uses the actor default. |
| `includeFeed` | true/false | `true` | Check visible Space/feed items. |
| `feedTab` | choice | `all` | Space feed section: all, posts, questions, top, unanswered, about, or rules. |
| `maxFeedItems` | number | `50` | Maximum visible feed items per Space. |
| `maxFeedQuestionExpansions` | number | `0` | Maximum feed questions to open for additional visible text. |
| `includeFeedText` | true/false | `true` | Keep text visible on feed cards. |
| `includeContributors` | true/false | `false` | Track visible Space contributors. |
| `maxContributors` | number | `50` | Maximum visible contributors per Space. |
| `includeSettings` | true/false | `false` | Track visible Space settings. |
| `includeRules` | true/false | `true` | Track visible Space rules. |
| `includeTopics` | true/false | `true` | Track visible Topic links. |
| `includeMedia` | true/false | `false` | Track visible image and video links. |
| `includeOutboundLinks` | true/false | `false` | Track links visible in watched content. |
| `onlyNewItems` | true/false | `false` | Return only items not present in the saved history. |
| `includeUnchanged` | true/false | `true` | Return an event when a successful observation has not changed. |
| `historyName` | text | generated for one-time checks | Stable name used to compare later runs. Reuse it for a scheduled monitor. |
| `changeDetail` | choice | `hash_and_summary` | `hash_only`, `field_summary`, `field_values`, or `hash_and_summary`. |
| `stateRetentionDays` | number | `0` | How long saved history is retained; `0` uses the default. |
| `language` | choice | `auto` | Language/locale for public page discovery. |
| `reachMode` | choice | `standard` | `standard`, `maximum`, or `direct` public access. |
| `outputFields` | list | all available | Optional field selection; usable event identity fields remain available. |
| `cookies` | list of browser cookies | none | Optional cookies from your own authorized Quora session. Never enter a password. |
| `includeAccessIssues` | true/false | `false` | Add a labelled row when Quora does not make a source available. |

All limits are upper bounds on visible observations. A failed or blocked observation is not treated as unchanged, removed, or deleted. Empty optional fields are omitted.

### Output per record

Each row describes a successful public observation or a clearly labelled access event. Values come from Quora; no change is invented.

#### Identity, event, and text

- `recordType`, `id`, `url`, `title`, `text`, `collectedAt`, `accessState`, `details`
- `eventType`, `changeType`, `changes`, `questionText`, `answerText`, `postText`, `commentText`, `profileBio`, `authorBio`, `topicDescription`, `spaceDescription`, `resultSnippet`

#### Watched content

- `questionId`, `questionUrl`, `questionTitle`, `questionPublishedAt`, `questionUpdatedAt`, `questionLastAnsweredAt`, `isUnanswered`, `topics`, `relatedQuestions`
- `answerId`, `answerUrl`, `answerPostedAt`, `answerCreatedAt`, `answerRelativeAge`, `answerUpdatedAt`, `answerRank`, `answerVisibility`, `answerTextCompleteness`, `answerAccessOption`, `isAiAnswer`, `isTopAnswer`, `isTruncated`
- `authorName`, `authorUrl`, `authorId`, `authorHandle`, `authorCredentials`, `authorImageUrl`, `authorIsVerified`, `username`

#### Counts, media, and relationships

- `answerCount`, `followerCount`, `followingCount`, `questionCount`, `postCount`, `memberCount`, `contributorCount`, `viewCount`, `upvotes`, `commentsCount`, `sharesCount`, `commentReplyCount`, `reactionCount`, `totalAnswerViews`, `totalContentViews`, `answerToViewRatio`, `followToAnswerRatio`, `answersCollected`, `answersLimitReached`
- `images`, `videos`, `externalLinks`, `textCompleteness`, `searchType`, `searchRank`, `searchTitle`, `searchSnippet`, `isPromoted`
- `fromUrl`, `toUrl`, `relationshipType`

Less-common observed values are retained under `details`. There are no run-summary, billing, parser, proxy, cookie, or repeated-input fields in content rows.

### Examples

#### Watch a public question

```json
{
  "directUrls": ["https://www.quora.com/What-are-the-major-differences-between-NAFTA-and-TPP"],
  "historyName": "trade-question-watch",
  "includeFeed": false,
  "includeUnchanged": true,
  "changeDetail": "field_values"
}
```

#### Watch a Space feed

```json
{
  "directUrls": ["https://www.quora.com/q/Pakistan"],
  "historyName": "pakistan-space-watch",
  "includeFeed": true,
  "feedTab": "questions",
  "maxFeedItems": 100,
  "includeFeedText": true
}
```

#### Watch a topic subdomain

```json
{
  "directUrls": ["https://cryptocurrency.quora.com/"],
  "historyName": "cryptocurrency-topic-watch",
  "includeFeed": true,
  "feedTab": "questions",
  "maxFeedItems": 25
}
```

#### Notify only about new items

```json
{
  "directUrls": ["https://www.quora.com/q/Urban-Planning"],
  "historyName": "urban-planning-new-items",
  "onlyNewItems": true,
  "includeUnchanged": false,
  "feedTab": "unanswered"
}
```

#### Watch public search results

```json
{
  "searchQueries": ["renewable energy cooperatives", "community health workers in Kenya"],
  "historyName": "global-research-queries",
  "includeFeed": false,
  "changeDetail": "hash_and_summary",
  "maxResults": 50
}
```

#### Example output

```json
{
  "recordType": "monitor_event",
  "eventType": "snapshot",
  "changeType": "initial_snapshot",
  "url": "https://www.quora.com/What-is-Python-primarily-used-for",
  "title": "What is Python primarily used for?",
  "accessState": "public"
}
```

### Use cases

- **Scheduled alerts:** detect new or changed public Quora content.
- **Community monitoring:** watch Space feeds, Topics, rules, and contributors.
- **Content operations:** identify when a public question or answer changes.
- **Research tracking:** compare search results across recurring runs.
- **Change review:** receive before/after values for important fields.

### FAQ

#### What is required for change detection?

Use the same `historyName` on later runs. The first successful run establishes the baseline.

#### Does a blocked page count as unchanged?

No. A blocked or incomplete observation is kept separate so it cannot create a false unchanged or deleted event.

#### Do I need cookies?

No. Cookies are optional and only add content available to your own authorized session. They cannot unlock private, removed, or Quora+ content.

#### What is the difference between `onlyNewItems` and `includeUnchanged`?

`onlyNewItems` limits feed output to items not already seen. `includeUnchanged` controls whether an unchanged observation event is returned.

#### How much history is retained?

`stateRetentionDays` controls retention. The exact number of changes also depends on what Quora makes visible on each run.

#### Can this detect every change on Quora?

It detects changes in the public values it can observe. Private, removed, gated, or challenge-protected content cannot be compared.

#### Why is a field missing from `changes`?

That value was not displayed in one of the observations, or the selected change detail does not include field-level values.

#### Is this affiliated with Quora?

No. This is a third-party actor using public Quora pages and public page data.

### Quora actor catalog

- [Quora Scraper](https://apify.com/crawlerbros/quora-scraper) — collect known public URLs, usernames, and mixed Quora content.
- [Quora Search Scraper](https://apify.com/crawlerbros/quora-search-scraper) — discover public Quora content from keywords and enrich matching pages.
- [Quora Dataset Builder](https://apify.com/crawlerbros/quora-dataset-builder) — build deduplicated content rows and explicit relationships.
- [Quora Monitor](https://apify.com/crawlerbros/quora-monitor-scraper) — compare watched pages, Spaces, and feeds across runs.

### Access notes

The actor attempts public Quora pages without cookies and reports only values actually observed. Standard, maximum, and direct choices help with different public-access conditions, but no scraper can guarantee a future response from Quora for every page.

# Actor input Schema

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

Terms whose public discovery results should be checked.

## `includeFeed` (type: `boolean`):

Check visible feed items for changes.

## `scrapeDepth` (type: `string`):

Summary only, or summary plus visible feed and contributors.

## `feedTab` (type: `string`):

Choose which visible Space section to monitor.

## `includeContributors` (type: `boolean`):

Check visible Space contributors for changes.

## `maxFeedItems` (type: `integer`):

Maximum visible feed items checked in each Space.

## `maxContributors` (type: `integer`):

Maximum visible contributors checked in each Space.

## `maxFeedQuestionExpansions` (type: `integer`):

When Scrape Depth is detail, bounded number of question-type feed items to open and expand into full question fields (question\_id, question\_answer\_count, question\_view\_count, question\_details, question\_created\_at, question\_updated\_at). Zero keeps the feed-digest-only behavior.

## `includeFeedText` (type: `boolean`):

Include visible feed text evidence.

## `includeMedia` (type: `boolean`):

Include visible media URLs when present.

## `includeOutboundLinks` (type: `boolean`):

Include bounded outbound links from feed cards.

## `includeRules` (type: `boolean`):

Keep visible Space rules and participation requirements.

## `includeTopics` (type: `boolean`):

Keep visible Topic labels and links associated with a watched page or Space.

## `includeSettings` (type: `boolean`):

Check visible Space rules and settings when rendered.

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

Requires an Apify state store; unchanged records are omitted.

## `includeUnchanged` (type: `boolean`):

Return records even when no visible change was detected.

## `stateRetentionDays` (type: `integer`):

Opt-in age-based pruning for unseen state snapshots; zero disables pruning.

## `language` (type: `string`):

Choose the Quora language version to request when available. This selects page language; it does not translate content.

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

Optional cookies from a Quora session you are authorized to use. Public monitoring is attempted without cookies first.

## `outputFields` (type: `array`):

Optional export selection for API users. Leave empty to return every observed buyer-relevant field; fields absent from a page are omitted.

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

Public Space, question, answer, profile, topic, or post URLs.

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

Maximum records returned across watched sources.

## `changeDetail` (type: `string`):

Choose whether to return hashes, changed fields, or previous/current values.

## `includeAccessIssues` (type: `boolean`):

Add one clearly labelled row for each page Quora did not make available. Leave off for a clean content-only dataset.

## `historyName` (type: `string`):

Optional stable name for comparing this source across scheduled runs.

## `maxResultsPerSource` (type: `integer`):

Maximum records collected from each URL or search source before moving to the next source.

## `reachMode` (type: `string`):

Standard is the cost-conscious default. Maximum reach uses stronger routing when available. Direct connection is mainly useful when you already control the connection.

## Actor input object example

```json
{
  "includeFeed": true,
  "scrapeDepth": "detail",
  "feedTab": "all",
  "includeContributors": false,
  "maxFeedItems": 50,
  "maxContributors": 50,
  "maxFeedQuestionExpansions": 0,
  "includeFeedText": true,
  "includeMedia": false,
  "includeOutboundLinks": false,
  "includeRules": true,
  "includeTopics": true,
  "includeSettings": false,
  "onlyNewItems": false,
  "includeUnchanged": true,
  "stateRetentionDays": 0,
  "language": "auto",
  "outputFields": [],
  "directUrls": [
    "https://www.quora.com/What-is-Python-primarily-used-for"
  ],
  "maxResults": 100,
  "changeDetail": "hash_and_summary",
  "includeAccessIssues": false,
  "historyName": "",
  "maxResultsPerSource": 0,
  "reachMode": "standard"
}
```

# Actor output Schema

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

Open all snapshots, changes, feed items, contributor records, and availability observations.

# 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 = {
    "includeFeed": true,
    "includeContributors": false,
    "maxFeedQuestionExpansions": 0,
    "includeFeedText": true,
    "includeMedia": false,
    "includeOutboundLinks": false,
    "includeRules": true,
    "includeTopics": true,
    "includeSettings": false,
    "onlyNewItems": false,
    "includeUnchanged": true,
    "directUrls": [
        "https://www.quora.com/What-is-Python-primarily-used-for"
    ],
    "includeAccessIssues": false,
    "maxResultsPerSource": 0
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/quora-monitor-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 = {
    "includeFeed": True,
    "includeContributors": False,
    "maxFeedQuestionExpansions": 0,
    "includeFeedText": True,
    "includeMedia": False,
    "includeOutboundLinks": False,
    "includeRules": True,
    "includeTopics": True,
    "includeSettings": False,
    "onlyNewItems": False,
    "includeUnchanged": True,
    "directUrls": ["https://www.quora.com/What-is-Python-primarily-used-for"],
    "includeAccessIssues": False,
    "maxResultsPerSource": 0,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/quora-monitor-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 '{
  "includeFeed": true,
  "includeContributors": false,
  "maxFeedQuestionExpansions": 0,
  "includeFeedText": true,
  "includeMedia": false,
  "includeOutboundLinks": false,
  "includeRules": true,
  "includeTopics": true,
  "includeSettings": false,
  "onlyNewItems": false,
  "includeUnchanged": true,
  "directUrls": [
    "https://www.quora.com/What-is-Python-primarily-used-for"
  ],
  "includeAccessIssues": false,
  "maxResultsPerSource": 0
}' |
apify call crawlerbros/quora-monitor-scraper --silent --output-dataset

```

## MCP server setup

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