# Quora Question, Answer & Relationship Dataset Builder (`nimbryxo-studio/quora-question-answer-and-relationship-dataset`) Actor

Build a structured Quora dataset from question, answer, profile, Topic, Space, and Post URLs or search terms, with the question-answer-comment chain and relationship links kept intact.

- **URL**: https://apify.com/nimbryxo-studio/quora-question-answer-and-relationship-dataset.md
- **Developed by:** [Nimbryxo-studio](https://apify.com/nimbryxo-studio) (community)
- **Categories:** Social media, Automation, Lead generation
- **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 & Relationship Dataset Builder

Build a structured Quora dataset from direct links or best-effort search discovery. Point it at question, answer, profile, Topic, Space, or Post URLs and it returns normalized rows for every entity it finds, with the question → answer → comment chain and author/topic links kept intact. Choose how deep to go, how the rows are shaped, and which relationship or feed data to include.

This is an independent, third-party actor. It is not affiliated with, endorsed by, or licensed by Quora, Inc. No Quora account, login, session cookie, or paid proxy is used or required.

### What this actor does

- Accepts question, answer, profile, Topic, Space, and Post URLs directly, plus best-effort search discovery. Typed seed lists (`questionUrls`, `answerUrls`, `topicUrls`, `spaceUrls`, `profileUrls`, `postUrls`) override route auto-detection.
- Empty fields are omitted; a missing field means the source did not expose it, never `null` or a sentinel.
- Parses Quora's server-rendered Relay payloads and double-decodes the `window.ansFrontendGlobals.data.inlineQueryResults` `.push()` strings; it does not depend on CSS classes or DOM selectors for the core fields.
- Paginates question answers with Quora's public `QuestionPagedListPaginationQuery` cursor, up to `maxAnswersPerQuestion` / `maxAnswers` / `maxAnswerPages`. Every paginated answer is checked against the page question (title/path, `linkedQuestion`, `originalQuestionIfDifferent`, and the answer permalink), so unrelated promoted answers cannot become dataset rows while legitimate merged variants still pass.
- Paginates comment areas and nested replies through `AllCommentsListQuery` (10+ pages with `after` cursors), with `maxCommentsPerAnswer` as the hard cap; this is opt-in and robots-sensitive.
- Optionally reads a Topic feed, a Space SSR multifeed, profile statistics, Topic statistics, and Post metrics.
- Optionally reads the public question `/log` audit for created time, view count, and asker identity (`includeQuestionAudit`), and paginates profile answer/question history (`includeProfileHistory`).
- Optionally resolves public identity lists for question followers, answer upvoters, profile followers/following, and Space roles through explicitly requested relationship types and the sensitive-data gate.
- Walks the question → answer → comment chain and keeps the links between them (`entity_edge` rows), so you can rebuild the conversation tree.
- Offers four output shapes via `outputFormat`: `normalized` (separate rows per entity, default), `nested` (answers grouped under their question, comments under their answer), `flat`, and `edges` (relationship rows plus any status rows).
- Reports a `status` row (rather than guessing) whenever a page is blocked, login-gated, removed, or otherwise inaccessible, and a `run_manifest` row summarizing the whole run.
- Leaves empty content fields out of each row rather than filling them with a guess. `0` and `false` are kept as real values.
- Never emits cookie/credential material. URLs are redacted when `redactSensitiveQueryParams` is on.

### Output per record

Every row carries `content_type` (`question`, `answer`, `comment`, `profile`, `profile_activity`, `topic`, `topic_post`, `space`, `space_feed_item`, `entity_edge`, `relationship_collection`, `status`, or `run_manifest`), plus shared fields: `record_id`, `title`, `url`, `canonical_url`, `source_url`, `access_state`, `scrape_timestamp`, `requested_depth`, `observed_depth`, `detail_expansion_state`, `output_format`, `matched_input`, `matched_input_kind`, and (when search seeds were used) `source_query`/`source_queries`.

Every row also carries run-context fields describing how it was collected: `source_observations`/`source_observation_count`, `redirect_chain`, `url_redaction_state`/`url_redactions`, `proxy_used`, `proxy_path_used`, `proxy_resolution_state`, `session_cookie_count`, `session_input_state`, `session_cookie_expiry_state`, `request_delay_seconds`, `browser_locale`, `requested_language`, `navigation_retries`/`navigation_retry_delays_seconds`, `parser_version` and `parser_strategy`. With `includeFieldEvidence` on (default), rows also get `field_sources` (where each value came from) and `fields_present`.

`access_state` is `public` for normal pages. Other values include `login_required`, `cloudflare_challenge`, `rate_limited`, `not_found`, `removed`, `unavailable`, `quora_plus_or_gated`, `quora_plus_preview`, `redirected_to_search`, `unsupported_url`, `search_unavailable`, `answer_pagination_limited`, `answer_pagination_unavailable`, `comments_unavailable`, `comments_capped`, `topic_feed_unavailable`, `topic_feed_capped`, `space_feed_capped`, `profile_history_limited`, `profile_history_unavailable`, `question_audit_unavailable`, `relationship_identity_unavailable`, `relationship_identity_capped`, `relationship_identities_not_observed`, `state_store_unavailable`, `state_store_uncommitted` and `network_error`.

**Question row** — `question_url`, `question_id`, `question_answer_count` (label) / `question_answer_count_value` (parsed number) / `question_answer_count_scraped` (rows actually collected), `question_follower_count` / `question_follower_count_value` (when the public payload exposes it), `related_questions` (`qid`, `title`, `url`), `question_created_at`, `question_updated_at`, `question_view_count`, `question_audit_state`, `question_merge_count`, `question_age_days`/`question_age_state`, `last_answered_at` + `last_answered_at_evidence`, `question_author_name`/`_url`/`_image_url`/`_id`/`_is_verified`/`_is_anonymous`/`_credentials` (from a visible author card or the opt-in `/log` audit), `question_image_urls`/`_video_urls`/`_outbound_links` (opt-in), `answer_count`, `answer_limit_reached`, `topics`, `topic_links`.

**Answer row** — `answer_id`, `answer_node_id`, `answer_url`, `answer_text`, `answer_html` (opt-in, derived from rich text), `answer_media_urls`/`_image_urls`/`_video_urls`/`_outbound_links` (opt-in), `answer_translation_state`/`_label`, `answer_original_url`, `answer_is_anonymous`, `answer_author_is_verified`, `answer_author_follower_count` (when present), `answer_created_at`/`_updated_at`, `answer_age_days`/`_state`, `answer_visibility`, `answer_text_completeness`, `answer_is_collapsed`, `answer_is_quora_plus`, `answer_access_option`, `answer_effective_access`, `answer_is_top_labeled`, `answer_rank`/`_rank_source`, `answer_upvote_count`/`_value`, `answer_comment_count`/`_value`, `answer_view_count`/`_value`, `answer_share_count`/`_value`, `reaction_breakdown` (opt-in), `is_ai_answer`/`ai_label_text`/`ai_label_source`, `related_content`/`_count`/`_observed_count`/`_limit_reached` (opt-in), `answer_jsonld_type`, `author_name`/`_url`/`_image_url`/`_id`/`_credentials`.

**Comment row** — `comment_id`, `comment_url`, `comment_text`, `comment_source` (`graphql_comment_area`), `comment_author_name`/`_image_url`/`_id`/`_credentials`/`_is_verified`, `comment_is_anonymous`, `comment_timestamp`/`_created_at`, `comment_age_days`/`_state`, `comment_visibility`, `comment_upvote_count`/`_value`, `comment_reaction_count`/`_value`, `comment_reply_count`/`_value`, `comment_reaction_breakdown`, `comment_media_urls`/`_image_urls`/`_video_urls`/`_outbound_links`, `comment_is_top_labeled`, `comment_rank`/`_rank_source`, `comment_sort_order`, `comment_depth`, `comment_depth_limit_reached`, `comment_is_reply`, `parent_comment_id`/`_url`, `comment_reply_path`, `comment_container_id`, `comment_items_observed_count`/`_emitted_count`, `comment_limit_reached`, `comment_page_limited`.

**Profile row** — `profile_url`, `profile_name`, `profile_bio`, `profile_image_url`, `profile_author_id`, `profile_is_verified`, `profile_is_restricted`, `profile_account_status`, `profile_is_anonymous`, `profile_is_deceased`, `profile_snapshot_state`, plus `profile_follower_count`, `profile_following_count`, `profile_answer_count`, `profile_question_count`, `profile_post_count`, `profile_total_content_views`, `profile_month_content_views`, `profile_joined_at`, `profile_credential`, `profile_work_credentials`, `profile_school_credentials`, `profile_location_credentials`, `profile_expertise_topics`, `profile_history_limited` when the visible feed is truncated or the opt-in history is capped, and `profile_history_state` (`not_requested`/`observed`/`capped`/`rate_limited`/`unavailable`/`empty`) when history is requested.

**Profile-activity row** — `activity_url`, `activity_type`, `activity_source`, `activity_question_url`/`_title`/`_id`, `activity_answer_id`, `created_at`, `author_name`/`_url`/`_image_url`/`_id`/`_credentials`.

**Topic row** — `topic_url`, `topic_id`, `topic_follower_count`, `topic_most_viewed_authors` (`uid`, `name`, `url`, `follower_count`, `num_views`, `num_public_most_viewed_answers`, `credential`), `topic_photo_url`, `topic_default_photo_url`, `topic_has_leaderboard`, and `topic_feed_state` (`not_requested`/`observed`/`capped`/`unavailable`).

**Topic-Post row** — `post_url`, `post_pid`, `post_node_id`, `post_title` (explicit title or first content line), `post_body`, `post_media_urls`/`_image_urls`/`_video_urls`/`_outbound_links` (opt-in), `post_author_name`/`_url`/`_image_url`/`_id`/`_credentials`/`_is_verified`/`_is_anonymous`/`_follower_count`, `post_question_url`/`_title`, `topic_url`, `post_created_at`/`_updated_at`, `post_age_days`/`_state`, `post_updated_age_days`/`_state`, `post_upvote_count`, `post_view_count`, `post_share_count`, `post_comment_count`, `post_effective_access`, `post_is_question_summary`.

**Space row** — `space_url`, `space_id`, `space_follower_count`, `space_all_time_followers` (conditional), `space_member_count`, `space_contributor_count`, `space_moderator_count`, `space_admin_count`, `space_description`, `space_icon_url`, `space_cover_url`, `space_item_count`, `space_feed_capped`, `space_ads_skipped`.

**Space feed-item row** — `feed_url`, `feed_type`, `feed_title`, `feed_text` (opt-in), `feed_post_pid`/`feed_post_node_id` (post stories), `feed_author_name`/`_url`/`_image_url`/`_id`/`_credentials`/`_is_verified`/`_is_anonymous`, `feed_created_at`, `feed_age_days`/`_state`, `feed_upvote_count`, `feed_view_count`, `feed_share_count`, `feed_comment_count`, `feed_effective_access`, `feed_is_ai_answer`, `feed_question_url`/`_title`, `media_urls`/`image_urls`/`video_urls`/`outbound_links` (opt-in).

**Relationship row (`entity_edge`)** — `relationship`, `edge_id`, `from_record_id`/`_content_type`/`_url`/`_id`, `to_record_id`/`_content_type`/`_url`/`_id`/`_name`/`_image_url`, `node_image_url`, `edge_state`, `unresolved_reason`, `edge_evidence_field`, `relationship_collection_key`, `collection_total_text`/`_value`.

**Relationship-count row (`relationship_collection`)** — `relationship_collection_key`, `collection_total_text`, `collection_total_value`, `edge_evidence_field`.

**Status row** — `access_state`, `http_status`, `error`, `source_url`, and for pages that failed to load `final_url`, `scrape_duration_ms`, `navigation_attempts`, `navigation_retries`. Run-level status rows (`url: run://quora-dataset-builder`) report a state store that could not be read (`state_store_unavailable`), state that was not saved because a source did not finish (`state_store_uncommitted`), or a run that produced no real rows (`no_records_emitted`).

**Option-dependent fields** — with a `stateStoreId`, entity rows add `event_type` (`new`/`changed`/`unchanged`/`scope_mismatch`), `state_snapshot_hash`, `previous_snapshot_hash`, `state_scope_fingerprint`, `state_store_state`, `only_new_items`, `include_unchanged`. With `includeRawEvidence`, page-level rows add `raw_html_sha256`, `raw_html_bytes`, `raw_html_truncated`, `raw_html_returned_bytes`, `raw_html_redaction_state`, `raw_html_redactions`, `raw_evidence_state`, `raw_evidence_retention_days`, plus `raw_html` when `includeHtml` is also on and `rawEvidenceRetentionDays` is above zero. In `nested` format, question rows carry `answers` arrays (each answer with its `comments`) and `nested_*` count fields. With `maxItemsPerSource` set, rows add `max_items_per_source` and per-source cap fields.

**Run-manifest row** — one per run, summarizing counts and the settings actually applied: `run_started_at`/`_finished_at`/`_duration_ms`, `records_emitted`, `source_pages_attempted`, `content_type_counts`, `access_state_counts`, `input_accounting`, `requested_result_types`, `requested_output_fields`, `dedupe_mode`, `duplicate_records_suppressed`, `proxy_path_used`, `proxy_resolution_state`, `search_discovery_source`, `search_discovery_hits`, `answer_gql_pages`, `answer_pagination_state`, `answer_pagination_unrelated_suppressed`, `comment_gql_pages`, `topic_feed_pages`, `space_feed_bundles`, `quora_plus_preview_count`, `comment_cap_hit_count`, `topic_feed_cap_hit_count`, `profile_history_pages`, `profile_history_state`, `relationship_identity_pages`, `relationship_identity_requests`, `relationship_identity_states`, `question_audit_state`, `question_audit_attempts`, `legacy_input_notes`, `hard_limits`, `gql_calls`, `query_hashes`, and the per-run values of your own input settings echoed back for reconciliation.

### Trimming rows, depth, sessions and caps

- **Field allowlist.** `outputFields` keeps only the fields you name, applied after extraction; an empty list returns the full row. Nested projection is supported with dotted paths such as `answers.answer_text` or `answers.comments.comment_text` in `nested` output. Child identity/URL fields stay in place, and `content_type`, identity, access/status, depth, timing and parser fields are always protected so a trimmed row can still be traced. `output_projection` on each row reads `full` or `selected`, and the run manifest records the requested fields. `includeFieldEvidence` toggles the `field_sources`/`fields_present` maps.
- **Depth.** `scrapeDepth: "detail"` (default) runs the capped traversal; `overview` emits page-level summaries without answer, comment, profile-activity or Space-feed expansion. Every row reports `requested_depth`, `observed_depth` and `detail_expansion_state`. `bounded` means a configured cap was reached, not that Quora's full history was collected, and blocked pages report `observed_depth: "status"`.
- **Caps.** `maxAnswersPerQuestion` bounds each question, `maxAnswers` is a global answer cap, `maxAnswerPages` bounds GraphQL pages explicitly, `maxItems` caps entity/status rows before graph/manifest rows, `maxItemsPerSource` caps each source, and `maxGraphEdges` caps relationship rows. When `maxItems`/`maxGraphEdges` is 0 the corresponding cap is off. `maxRelationshipItemsPerCollection` bounds each labeled relationship collection, `maxRelationshipPages` bounds each public identity-list query, and `maxProfileHistoryPages` bounds each profile answer/question list. `answer_pagination_limited` is emitted only when a configured page cap or a GraphQL rate limit stopped pagination; an exhausted source is not reported as a cap.
- **Comments.** Set `includeComments: true`. When `maxCommentsPerAnswer` is 0, the documented fallback is 10 per answer. The actor calls `AllCommentsListQuery` with `after` cursors and a page size derived from your cap (up to 50), so a 24-comment answer is collected as 10 + 10 + 4 when the server pages at ten. `includeCommentReplies` (or `includeReplyGraph`) expands nested replies up to `maxCommentDepth`; `comment_page_limited` is set only when a cap is actually hit, and a `comments_capped` status row follows. If the paginated query fails, the actor falls back to the first-page loader rather than inventing rows. Comments use Quora's comment-area GraphQL, which `robots.txt` disallows for generic agents: keep this opt-in and review your own compliance posture.
- **Topic feed.** Set `includeTopicFeed: true` to call the topic page's own public GraphQL feed. `maxTopicFeedPages` bounds pages. This path is also robots-sensitive; keep it opt-in.
- **Question audit.** `includeQuestionAudit: true` reads the question's public `/log` page for `question_created_at`, `question_view_count`, `question_merge_count`, and the asker name/uid/profile/credential. It retries a transient 403 once, then keeps `question_audit_state: "unavailable"` and a `question_audit_unavailable` status row. `/log` is robots-disallowed for generic agents and is never part of the daily prefill.
- **Profile history.** `includeProfileHistory: true` paginates `UserProfileAnswersMostRecent_RecentAnswers_Query` and `UserProfileQuestionsList_Questions_Query` and emits bounded `profile_activity` rows. `maxProfileHistoryPages` (default 0 = three pages per list) and `requestDelay` (used as a 1.5–2.5 s GraphQL pace when above zero) bound the work. A cap sets `profile_history_limited`; a 400/403 sets `profile_history_state: "rate_limited"` and a `profile_history_unavailable` status row instead of fabricated rows.
- **Identity lists.** Identity rows are emitted only when `relationshipTypes` explicitly requests them, the matching family flag is on, and `includeSensitiveRelationshipData` is on for sensitive types. The public GraphQL operations cover profile followers/following people/questions/Spaces/Topics, question followers, answer upvoters, and Space admins/contributors/moderators/followers. `maxRelationshipItemsPerCollection` and `maxRelationshipPages` bound every list; Space role calls run from a `www.quora.com` page context. These lists are robots-sensitive and rate-sensitive; a failure keeps a `relationship_identity_unavailable` or `relationship_identities_not_observed` status row, and a page/item cap adds `relationship_identity_capped`.
- **Sessions and proxies.** No account, login, cookie, or session secret is used. The transport ladder is direct (`curl_cffi`, fresh session per attempt) → optional user proxy override → Apify AUTO datacenter → RESIDENTIAL only as a hardcoded last resort after the free rungs fail. A missing `proxyConfiguration` never stops the run, and there is no paid default. `proxy_path_used` reports the rung that worked.
- **Exact field names.** Every output field this actor can emit is listed under [Output per record](#output-per-record) above. Fields whose source is absent on a given page are omitted, not set to null or a sentinel.

### Complete schema input inventory

Every input is optional. The daily prefill uses one public question URL with a small answer cap, comments and feeds off, and no paid proxy.

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `auto` | `auto` / `byQuestionUrls` / `byAnswerUrls` / `byProfileUrls` / `byTopicUrls` / `bySpaceUrls` / `byPostUrls` / `search`; typed modes validate seed routes |
| `scrapeDepth` | string | `detail` | `overview` (page-level summary only) or `detail` (full capped traversal) |
| `startUrls` | array | `[]` | Question, answer, profile, Topic, Space, or Post URLs; mixed lists are auto-detected and invalid hosts become status rows |
| `searchQueries` | array | `[]` | Best-effort discovery terms; Quora's native search is login/Cloudflare-gated and is never claimed |
| `questionUrls` | array | `[]` | Typed question seeds |
| `answerUrls` | array | `[]` | Typed answer-permalink seeds |
| `topicUrls` | array | `[]` | Typed Topic seeds |
| `spaceUrls` | array | `[]` | Typed Space seeds; automatically enables Space output |
| `profileUrls` | array | `[]` | Typed profile seeds |
| `postUrls` | array | `[]` | Typed standalone Post seeds |
| `resultTypes` | array | `["question","answer","comment","profile","profile_activity","topic","topic_post","space","space_feed_item","entity_edge","status","run_manifest"]` | Which `content_type` values to include |
| `outputFormat` | string | `normalized` | `normalized` / `nested` / `flat` / `edges` |
| `dedupeMode` | string | `canonical` | `canonical` (merge duplicate entities by canonical URL/ID) or `none` |
| `onlyNewItems` | boolean | `false` | With `stateStoreId`, suppress rows unchanged since the last run |
| `includeUnchanged` | boolean | `true` | Keep unchanged rows when `onlyNewItems` is on |
| `stateStoreId` | string | - | Apify key-value store name for incremental re-scraping; required when `onlyNewItems` is on |
| `outputFields` | array | `[]` | Optional field allowlist for smaller rows; identity/status fields are always kept |
| `includeFieldEvidence` | boolean | `true` | Include `field_sources`/`fields_present` on each row |
| `includeUnresolvedEdges` | boolean | `true` | Keep relationship rows whose target could not be matched |
| `relationshipTypes` | array | `[]` | Allowlist of labeled relationship collections to expand (follower, following, want-answers, upvoter, Space role); identity-revealing types also need `includeSensitiveRelationshipData` and the matching family opt-in |
| `includeProfileEdges` | boolean | `false` | Per-family opt-in for profile follower/following/question/space/topic relationships |
| `includeQuestionFollowerEdges` | boolean | `false` | Per-family opt-in for question follower/want-answer identities (sensitive) |
| `includeAnswerUpvoterEdges` | boolean | `false` | Per-family opt-in for answer upvoter identities (requires `includeSensitiveRelationshipData`) |
| `includeSensitiveRelationshipData` | boolean | `false` | Privacy gate required for identity-revealing relationship collections |
| `includeTargetMetadata` | boolean | `false` | Keep the visible name/image of each relationship target |
| `includeRelationshipCounts` | boolean | `false` | Emit privacy-preserving member-count rows; also add `relationship_collection` to `resultTypes` |
| `includeSpaceRoleEdges` | boolean | `false` | Keep Space contributor/moderator/admin edges |
| `includeSpaceContentEdges` | boolean | `true` | Keep Space to post/question membership edges and feed-item membership |
| `maxRelationshipItemsPerCollection` | integer | `500` | Cap per labeled relationship collection |
| `maxQuestions` | integer | `25` | How many discovered question links get queued on top of your own seed URLs |
| `maxAnswersPerQuestion` | integer | `10` | Maximum answer rows kept per question after SSR and GraphQL pagination |
| `maxAnswers` | integer | `0` | Global answer cap across the whole run (`0` = no cap) |
| `includeQuestion` | boolean | `true` | Keep question entities in the output |
| `includeAuthor` | boolean | `true` | Keep author/profile entities and author fields in the output |
| `includeAuthorSnapshot` | boolean | `false` | Fetch a bounded profile snapshot for each visible answer author |
| `includeTopics` | boolean | `true` | Keep topic entities and topic links |
| `includeSpaces` | boolean | `false` | Keep Space and Space feed-item rows; switched on automatically when a Space URL is used in `startUrls` or `spaceUrls` |
| `includeComments` | boolean | `false` | Opt-in comment rows with `AllCommentsListQuery` cursor pagination; robots-sensitive |
| `includeEngagementBreakdown` | boolean | `true` | Include per-reaction breakdowns alongside aggregate counts |
| `includeRelatedContent` | boolean | `false` | Collect explicitly attached answer related-content links when Quora's public payload exposes them; otherwise they are omitted |
| `maxRelatedContent` | integer | `20` | Bound related-content links per answer when enabled; zero emits no related-content items |
| `topCommentsOnly` | boolean | `false` | Keep only comments explicitly labeled Top/Most helpful |
| `commentSortOrder` | string | `observed` | `observed` / `upvotes_desc` / `reactions_desc` / `replies_desc` / `newest` |
| `includeReplyGraph` | boolean | `false` | Compatibility alias that enables comments and nested replies |
| `includeMedia` | boolean | `false` | Include image/video URL fields where available |
| `includeFeedText` | boolean | `false` | Include visible text on Space feed cards |
| `includeOutboundLinks` | boolean | `false` | Include non-Quora links found in rich text |
| `includeEntityGraph` | boolean | `false` | Emit relationship rows even when `entity_edge` is not in `resultTypes` |
| `maxCommentsPerAnswer` | integer | `0` | Comments kept per answer; when comments are on and this is 0, the fallback is 10; the cap is the pagination limit, not a page size |
| `maxCommentDepth` | integer | `20` | Maximum nested reply depth when replies are enabled; 0 disables replies |
| `maxItems` | integer | `0` | Cap on entity/status rows before graph and manifest rows (`0` = no cap) |
| `maxGraphEdges` | integer | `5000` | Cap on relationship rows (`0` = no edges) |
| `maxScrollAttempts` | integer | `5` | Scroll attempts per page in detail mode |
| `maxLoadMoreAttempts` | integer | `0` | "Load more" button clicks per page |
| `includeRawEvidence` | boolean | `false` | Attach a document hash and size/redaction metadata for auditing |
| `includeHtml` | boolean | `false` | Retain bounded raw HTML on page-level rows and derived answer HTML |
| `maxHtmlBytes` | integer | `100000` | Upper bound for retained or derived HTML |
| `requestDelay` | number | `1` | Delay in seconds between page batches |
| `maxConcurrency` | integer | `1` | Independent seeds processed in parallel (values above 3 are treated as 3) |
| `maxNavigationRetries` | integer | `2` | Retries after a failed page load (max 3) |
| `language` | string | `auto` | Browser language hint (`en`, `es`, `fr`, ...); not a translation guarantee |
| `proxyConfiguration` | object | - | Optional proxy override. The free ladder runs first; there is no paid default |
| `redactSensitiveQueryParams` | boolean | `true` | Redact credential-like query values and fragment credentials from emitted URLs/HTML |
| `rawEvidenceRetentionDays` | integer | `30` | Retention label for raw HTML evidence; 0 keeps metadata only |
| `maxRawEvidenceBytes` | integer | `100000` | Size bound for raw HTML evidence |
| `maxItemsPerSource` | integer | `0` | Cap on records from each individual source URL/query (`0` = no cap) |
| `searchDiscovery` | string | `relatedOnly` | `relatedOnly` (related questions only) / `bestEffortIndex` (third-party index) / `off` |
| `maxRelatedQuestions` | integer | `20` | Related questions enqueued per question seed |
| `searchResultsPerQuery` | integer | `10` | Maximum best-effort index results per query |
| `maxAnswerPages` | integer | `0` | Explicit answer GraphQL page cap; 0 derives from `maxAnswersPerQuestion` |
| `maxTopicFeedPages` | integer | `3` | Topic-feed GraphQL page cap when `includeTopicFeed` is on (minimum one page) |
| `maxSpaceFeedBundles` | integer | `4` | Space feed bundles read from the SSR multifeed |
| `includeCommentReplies` | boolean | `false` | Expand nested `repliesConnection` comment replies |
| `includeQuoraPlusPreview` | boolean | `true` | Emit Quora+ preview answers with preview flags; when false, omit them |
| `includeProfileStats` | boolean | `true` | Emit profile follower/following/answer/question/post/view/joined/credential fields |
| `includeTopicStats` | boolean | `true` | Emit Topic follower count and most-viewed authors |
| `includeSpaceStats` | boolean | `true` | Emit Space counters, description, icon and cover |
| `includePostStats` | boolean | `true` | Emit Post counters, effective access and question-summary flag |
| `includeAnswerStats` | boolean | `true` | Emit answer counters, dates, AI flag and effective access |
| `includeTopicFeed` | boolean | `false` | Browser GraphQL Topic feed; opt-in and robots-sensitive |
| `includeQuestionAudit` | boolean | `false` | Read the public question `/log` for created time, view count, merge count, and asker identity; robots-sensitive opt-in |
| `includeProfileHistory` | boolean | `false` | Paginate the public profile answer/question tabs into bounded `profile_activity` rows; robots- and rate-sensitive opt-in |
| `maxProfileHistoryPages` | integer | `0` | Cap per profile history list; 0 derives three pages (about 30 items per list) |
| `maxRelationshipPages` | integer | `3` | Cap per public identity-list query after the relationship allowlist and privacy gates |

### Example inputs

#### Example: full detail for a question

```json
{
  "questionUrls": [{ "url": "https://www.quora.com/What-is-the-best-way-to-learn-Python" }],
  "maxAnswersPerQuestion": 20,
  "includeComments": true,
  "maxCommentsPerAnswer": 10
}
```

#### Example: best-effort search discovery, compact nested output

```json
{
  "searchQueries": ["machine learning career advice"],
  "searchDiscovery": "relatedOnly",
  "maxQuestions": 10,
  "outputFormat": "nested",
  "maxAnswersPerQuestion": 5
}
```

#### Example: a Space's content and follower count

```json
{
  "spaceUrls": [{ "url": "https://www.quora.com/q/example-space" }],
  "resultTypes": ["space", "space_feed_item", "relationship_collection", "run_manifest"],
  "includeRelationshipCounts": true,
  "relationshipTypes": ["space_has_contributor"]
}
```

#### Example: incremental re-scrape of the same question

```json
{
  "questionUrls": [{ "url": "https://www.quora.com/What-is-the-best-way-to-learn-Python" }],
  "onlyNewItems": true,
  "includeUnchanged": false,
  "stateStoreId": "python-question-watch"
}
```

### Use cases

- **Content research** — pull full question-answer-comment threads on a topic for analysis
- **Community monitoring** — re-scrape the same questions on a schedule and keep only rows flagged `new`/`changed`
- **Knowledge graph building** — use `outputFormat: "edges"` to load the question/answer/topic relationship graph into a graph database
- **Influencer and expert tracking** — follow a profile's visible answers and its public follower/following/content statistics
- **Space analysis** — collect a Quora Space's feed, metrics and contributor counts

### FAQ

**Do I need a Quora account?**
No. Direct public question, answer, profile, Topic, Space, and Post pages are read without login. The actor never asks for, stores, or emits cookies or session secrets.

**Why did I get a `status` row instead of question/answer data?**
Quora showed a login wall, Cloudflare challenge, a removed page, or an unsupported redirect for that URL. The actor reports this honestly as a `status` row instead of guessing at data that was not there. A run with zero real rows also gets a `no_records_emitted` status row and a non-success status message.

**Why do I sometimes get fewer answers than `maxAnswersPerQuestion`?**
The actor reads the server-rendered answers, filters out answers whose question is provably unrelated, then paginates the public GraphQL cursor up to your cap. If the question genuinely has fewer answers, the cursor stops; you get the answers that were observable and no `answer_pagination_limited` row, because the source was exhausted rather than capped. `answer_pagination_limited` appears only when `maxAnswerPages`/your cap stopped a non-exhausted source or Quora rate-limited a pagination request, and the page's known `answerCount` is not already satisfied; a non-rate GraphQL failure uses `answer_pagination_unavailable`. Neither case fabricates an answer.

**How do I get question created time, view count, or the asker?**
Set `includeQuestionAudit: true`. The actor reads the public `/<question>/log` page (robots-sensitive, opt-in) and fills `question_created_at`, `question_view_count`, `question_merge_count`, and the `question_author_*` fields. Without it, those fields are omitted rather than guessed. A blocked `/log` leaves `question_audit_state: "unavailable"` and a status row.

**How do I get more than the three visible profile history items?**
Set `includeProfileHistory: true`. The actor paginates the public answer/question tab connections into `profile_activity` rows, bounded by `maxProfileHistoryPages` and paced by `requestDelay`. This GraphQL path is robots- and rate-sensitive; a 400/403 leaves a `profile_history_unavailable` status row and no fabricated rows.

**What is the difference between the four `outputFormat` values?**
`normalized` keeps every entity as its own row (the default). `nested` groups each question's answers (and each answer's comments) underneath it; rows without a matching parent stay at the top level with an orphan reason. `flat` is like `normalized`, except answer rows also get question context and comment rows get `answer_url`. `edges` returns the relationship rows between entities plus any status rows.

**Can I get a Quora account's followers, question followers, answer upvoters, or Space roles?**
Yes, as explicit opt-ins. Request the relationship type in `relationshipTypes`, turn on the matching family flag (`includeProfileEdges`, `includeQuestionFollowerEdges`, `includeAnswerUpvoterEdges`, or `includeSpaceRoleEdges`), and set `includeSensitiveRelationshipData: true` for follower/upvoter/want-answer types. The actor then calls the public identity-list GraphQL operations, paginates up to `maxRelationshipPages`, and emits only identities whose profile/question/Space/Topic URLs it observed. It may also use visible DOM links as a fallback. These paths are robots- and rate-sensitive; failures produce `relationship_identity_unavailable` or `relationship_identities_not_observed` status rows. It never invents identities.

**What does the incremental re-scrape (`onlyNewItems`) actually compare?**
It hashes each entity's semantic content and compares it to the previous run stored under `stateStoreId`, tagging each row `new`, `changed`, `unchanged`, or `scope_mismatch` (the previous run used different settings). Rows are only dropped when `onlyNewItems` is on and `includeUnchanged` is off. Status and manifest rows are never dropped by this setting. If any requested source did not finish, the new state is not saved and a `state_store_uncommitted` status row tells you so.

**Why are some text/media fields missing even with `includeMedia`/`includeHtml` on?**
Those fields are only populated when Quora's public payload actually contains that content for the entity in question. The toggles request the data; they do not guarantee every entity has it.

**Is search native Quora search?**
No. Quora's native `/search?q=` is login/Cloudflare-gated for logged-out clients and is disallowed by `robots.txt`. `searchQueries` uses related-question discovery by default and an optional third-party best-effort index; if no public results are discoverable it emits a `search_unavailable` status row.

**What are the hard limitations?**
Native Quora search is not available cookielessly: `/search?q=` redirects and the public search GraphQL returns no connection. Quora+ `smart_distribution` answers may be preview/truncated; they are flagged `answer_is_quora_plus` and their observed completeness is reported, and no gated remainder is fabricated. Space all-time views/upvotes/comments are private (tested across ten diverse Spaces), Topic description and question count are absent, and question description is absent. Space `allTimeFollowers` is emitted as `space_all_time_followers` only when the payload carries it (not every Space does).

Question created/view/asker, full profile history, comment/reply pagination, and identity lists are technically available through public pages/GraphQL but are **robots-sensitive and/or rate-sensitive opt-ins**; they are off by default and not part of the daily prefill. Be aware that `robots.txt` for generic agents disallows `/` broadly, including `/*_POST`, `/*/log`, `/*/followers`, `/*/following`, and `/*/comments`; product/legal review decides whether to enable those opt-ins. Quora URLs are valid in a browser, but plain HTTP clients can receive a Cloudflare 403 on HEAD/GET; the actor fetches them with TLS impersonation.

**Is this affiliated with Quora?**
No. This is an independent, third-party actor that reads public Quora pages; it is not affiliated with or endorsed by Quora, Inc. You are responsible for how you use the data.

# Actor input Schema

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

Optional dispatcher. auto detects every supported Quora route; typed modes validate startUrls against that route. Typed seed lists still work without mode.

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

Overview emits page metadata without answer/comment/feed expansion; detail enables SSR answers plus bounded GraphQL pagination and optional comments/topic feeds.

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

Question, answer, profile, topic, Space, or search URLs. Mixed lists are auto-detected; invalid hosts become status rows instead of failing the run.

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

Best-effort public-index discovery only. Quora native search is login/Cloudflare-gated and robots-disallowed; related-question expansion on a question URL is the reliable discovery axis.

## `questionUrls` (type: `array`):

Explicit question-page seeds. Only question routes are accepted.

## `answerUrls` (type: `array`):

Explicit answer-page seeds. Parent question joins are emitted only from observed evidence.

## `topicUrls` (type: `array`):

Explicit Topic-page seeds for bounded visible question discovery.

## `spaceUrls` (type: `array`):

Explicit Space-page seeds for bounded visible feed discovery.

## `profileUrls` (type: `array`):

Explicit profile-page seeds. Only profile routes are accepted; emitted as normalized profile rows exactly like a profile route discovered from startUrls.

## `postUrls` (type: `array`):

Explicit standalone Post-page seeds. Only post routes are accepted; emitted with the same topic_post field family topic-discovered posts use (post_title, post_body, post_author\_\*).

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

Select normalized entities, explicit graph relationships, relationship-collection counts, status rows, and the final run manifest.

## `outputFormat` (type: `string`):

Projection after one canonical extraction path. Nested groups emitted answers and comments under explicit question/answer parents; flat keeps entity rows with parent context; edges emits explicit edge rows plus status rows.

## `dedupeMode` (type: `string`):

canonical suppresses overlapping entity rows by stable ID or canonical URL (default); none preserves every observed non-status row. The run manifest reports duplicate_records_suppressed.

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

Annotate canonical entity rows with new/changed/unchanged/scope_mismatch state and suppress only unchanged semantic rows when includeUnchanged is false. Requires stateStoreId; status, graph, and manifest rows remain visible.

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

Retain unchanged semantic entities when incremental state is enabled; output projection does not alter comparison hashes.

## `stateStoreId` (type: `string`):

Apify key-value store for canonical entity snapshots. Required when onlyNewItems is enabled; never store cookies or credentials here.

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

Optional allowlist for compact rows, including bounded dotted paths through nested collections (for example answers.answer_text, comments.comment_text, feed.feed_text, or contributors.contributor_name where applicable). Child identity/URL fields and the actor identity, access/status, source, traversal, graph, filter, and parser-envelope fields remain protected.

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

Include field_sources and fields_present maps. Disable only when a smaller payload is required; semantic values and protected access fields remain unchanged.

## `includeUnresolvedEdges` (type: `boolean`):

Retain relationship rows whose endpoint URL was not explicitly observed, with unresolved_reason. Disabling this suppresses only those edge rows and does not imply complete relationships.

## `relationshipTypes` (type: `array`):

Explicit relationship-type allowlist for the newly ported follower/following/want-answers/upvoter/space-role relationship collections. Empty leaves the existing always-on content-membership/authorship edges untouched (question_has_topic, answer_authored_by, comment_belongs_to_answer, profile_has_activity, space_has_feed_item, etc.); this allowlist only gates the additional collections below. Sensitive follower/want-answer/upvoter types also require includeSensitiveRelationshipData and their matching collection opt-in.

## `includeProfileEdges` (type: `boolean`):

Enable explicitly labeled profile follower/following/followed-question/Space/Topic relationship collections. This does not prove a complete list.

## `includeQuestionFollowerEdges` (type: `boolean`):

Enable explicitly labeled question follower or want-answer collections. Sensitive identity rows also require the privacy gate.

## `includeAnswerUpvoterEdges` (type: `boolean`):

High-sensitivity opt-in for explicitly labeled answer upvoter identities; requires includeSensitiveRelationshipData=true.

## `includeSensitiveRelationshipData` (type: `boolean`):

Explicit privacy gate required for follower, want-answer, and upvoter identity edges.

## `includeTargetMetadata` (type: `boolean`):

Retain explicitly visible target link text and image (to_name, to_image_url) on relationship edges. URLs remain evidence; no target navigation or recursive target scraping is performed.

## `includeRelationshipCounts` (type: `boolean`):

Emit privacy-preserving relationship_collection rows with the real observed total (collection_total_text/collection_total_value) but no target identities. Requires relationship_collection in resultTypes. Observed totals are not always a server-confirmed count.

## `includeSpaceRoleEdges` (type: `boolean`):

Enable explicitly labeled Space contributor, moderator, and admin collections.

## `includeSpaceContentEdges` (type: `boolean`):

Retain bounded explicit Space post/question membership edges; this never claims a complete Space inventory.

## `maxRelationshipItemsPerCollection` (type: `integer`):

Bound explicit links emitted from each labeled relationship collection. Zero emits no relationship-collection edges and never means an empty collection.

## `maxQuestions` (type: `integer`):

Maximum question seeds or discovered question pages to process.

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

Maximum answer rows retained per question after SSR and GraphQL pagination.

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

Global answer-row cap applied after per-question caps. Zero means no configured global answer cap.

## `includeQuestion` (type: `boolean`):

Retain normalized question parent rows when selected in resultTypes.

## `includeAuthor` (type: `boolean`):

Retain visible author fields and profile/profile-activity rows. When false, author fields and author rows are removed from the emitted shape; no contact enrichment is performed.

## `includeAuthorSnapshot` (type: `boolean`):

Opt into bounded public profile snapshots for visible author profile links; profile access/status is separate from answer/comment success and never includes contact enrichment.

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

Retain explicit topic links and topic relationships where observed.

## `includeSpaces` (type: `boolean`):

Retain Space rows and SSR feed items. Explicit spaceUrls enable this automatically.

## `includeComments` (type: `boolean`):

Opt-in comment rows from Quora's public comment-area GraphQL. robots-sensitive; off by default. When enabled and maxCommentsPerAnswer is 0, the documented fallback is 10 per answer.

## `includeEngagementBreakdown` (type: `boolean`):

Retain explicitly labeled per-comment reaction breakdowns alongside aggregate reaction labels. Raw labels are preserved and typed companions are added only when the localized number is unambiguous.

## `includeRelatedContent` (type: `boolean`):

Retain links inside an explicitly labeled related/attached region scoped to answer cards; unlabeled navigation and neighboring regions are excluded.

## `maxRelatedContent` (type: `integer`):

Bound eligible related-content links per answer when enabled; zero emits no related-content items.

## `topCommentsOnly` (type: `boolean`):

Retain only comments with an explicit visible Top/Most helpful/Popular comments label. Unknown comments are excluded and counted; votes and position are not used as top evidence.

## `commentSortOrder` (type: `string`):

Order builder comment rows by observed order or an explicitly typed metric/timestamp. Unknown selected metrics remain in stable fallback order and are counted.

## `includeReplyGraph` (type: `boolean`):

Enable comment rows plus one-level nested reply extraction from repliesConnection. Requires includeComments.

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

Request explicitly rendered media URL fields scoped to question roots, answer/comment nodes, and Topic post cards where the page exposes them.

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

Request bounded visible text from explicitly linked Space feed cards; page-level text and complete feed history are excluded.

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

Request visible non-Quora links scoped to question roots, answer/comment nodes, and Topic post cards; Quora links, comment permalinks, and links outside the owning scope are excluded.

## `includeEntityGraph` (type: `boolean`):

Emit explicit relationship rows even when entity_edge is not listed in resultTypes.

## `maxCommentsPerAnswer` (type: `integer`):

Maximum comment rows retained per answer when comments are enabled. Schema default 0 is kept for compatibility; comments-enabled runs treat 0 as 10.

## `maxCommentDepth` (type: `integer`):

Maximum nested reply depth when includeCommentReplies/includeReplyGraph is enabled.

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

Cap for normalized entity/status rows before graph and manifest rows.

## `maxGraphEdges` (type: `integer`):

Independent cap for deterministic entity_edge rows.

## `maxScrollAttempts` (type: `integer`):

Bounded lazy-render scroll budget applied during detail traversal; scroll attempts and termination state are reported.

## `maxLoadMoreAttempts` (type: `integer`):

Bound exact visible continuation-control clicks on direct question, answer, topic, and Space collection pages independently from scrolling. Search seeds fan out through their discovered child URLs and retain their own source accounting.

## `includeRawEvidence` (type: `boolean`):

Add bounded document hash and optional HTML bytes to each page-level entity row.

## `includeHtml` (type: `boolean`):

Include bounded raw-document HTML when raw evidence is enabled and bounded answer-card HTML when answer cards are extracted.

## `maxHtmlBytes` (type: `integer`):

Maximum UTF-8 bytes retained for optional raw HTML evidence.

## `requestDelay` (type: `number`):

Delay between page batches in seconds; this is not an anti-bot bypass guarantee.

## `maxConcurrency` (type: `integer`):

Maximum independent seed pages processed concurrently in deterministic batches. Each seed owns a page; discovered seeds merge in batch order.

## `maxNavigationRetries` (type: `integer`):

Bounded retries after navigation exceptions (e.g. a transient proxy-tunnel handshake failure); exponential backoff is reported in navigation_retry_delays_seconds. Defaults to 2 for reliability.

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

Browser language hint. Short language codes and supported regional aliases are accepted and normalize to the short code; auto keeps the actor default. This does not translate content or prove access.

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

Optional proxy override. The actor starts with a direct connection, retries a fresh session on 403/429, then uses Apify AUTO datacenter proxies, and only falls back to RESIDENTIAL as a proven last resort. Leave this unset; a missing proxyConfiguration never stops the run.

## `redactSensitiveQueryParams` (type: `boolean`):

Redact narrow credential-like query parameter values in emitted URLs, graph endpoints, redirect chains, and raw HTML. The original document hash remains based on the captured document.

## `rawEvidenceRetentionDays` (type: `integer`):

When zero, suppress raw_html snapshots while retaining hash, size, and redaction diagnostics. Positive values permit bounded HTML for the requested run; external Apify dataset/run retention still applies.

## `maxRawEvidenceBytes` (type: `integer`):

Hard upper byte cap for returned raw HTML after the maxHtmlBytes cap.

## `maxItemsPerSource` (type: `integer`):

Maximum semantic records emitted from each direct URL, query, or typed source. Status and run-manifest rows are preserved. Use 0 for no per-source cap.

## `searchDiscovery` (type: `string`):

How searchQueries are handled. relatedOnly attempts Quora's public search and otherwise emits search_unavailable; bestEffortIndex queries a public web index for indexed Quora URLs. Native Quora search is never claimed.

## `maxRelatedQuestions` (type: `integer`):

Related questions to enqueue per question/topic seed. The page usually exposes 26-35; zero disables related-question discovery.

## `searchResultsPerQuery` (type: `integer`):

Maximum indexed URLs to use per search query when searchDiscovery=bestEffortIndex.

## `maxAnswerPages` (type: `integer`):

Bound QuestionPagedListPaginationQuery pages. Zero derives a bound from maxAnswersPerQuestion.

## `maxTopicFeedPages` (type: `integer`):

Bound topic-feed GraphQL pages when includeTopicFeed is enabled.

## `maxSpaceFeedBundles` (type: `integer`):

Bound Space feed bundles read from the SSR multifeed.

## `includeCommentReplies` (type: `boolean`):

Include nested repliesConnection rows. Requires includeComments. Comments are robots-sensitive and opt-in; zero-row/blocked results produce a status row.

## `includeQuoraPlusPreview` (type: `boolean`):

Emit preview-only answers flagged answer_is_quora_plus/answer_text_completeness=preview. The gated remainder is never fetched or presented as full text.

## `includeProfileStats` (type: `boolean`):

Emit follower/following/answer/question/post/view counts, joined date, credentials and expertise topics for profile rows.

## `includeTopicStats` (type: `boolean`):

Emit topic follower count and most-viewed authors for topic rows.

## `includeSpaceStats` (type: `boolean`):

Emit Space follower/member/contributor/moderator/admin counts, description, icon and cover.

## `includePostStats` (type: `boolean`):

Emit post upvotes/views/shares/comments, effective access and question-summary flag.

## `includeAnswerStats` (type: `boolean`):

Emit answer counters, dates, AI flag, effective access and Quora+ preview flags.

## `includeTopicFeed` (type: `boolean`):

Opt into the browser topic-feed GraphQL endpoint. robots-sensitive: keep off unless you accept that compliance caveat.

## `includeQuestionAudit` (type: `boolean`):

Opt into the public question /log page to fill question_created_at, question_view_count and the asker fields. robots.txt disallows /\*/log for generic agents; the actor never includes this in the default prefill.

## `includeProfileHistory` (type: `boolean`):

Opt into the public profile answer/question tab GraphQL and emit bounded profile_activity rows. robots-sensitive and rate-sensitive; on a 400/403 the run keeps a profile_history_unavailable status row.

## `maxProfileHistoryPages` (type: `integer`):

Bound for each profile history list (answers and questions) when includeProfileHistory is enabled. Zero derives three pages; one page is roughly ten items.

## `maxRelationshipPages` (type: `integer`):

Bound for each public identity-list query (question followers, answer upvoters, profile followers/following, Space roles) after the relationship allowlist and privacy gates. Zero is treated as one page.

## Actor input object example

```json
{
  "mode": "auto",
  "scrapeDepth": "detail",
  "startUrls": [
    {
      "url": "https://www.quora.com/What-is-the-meaning-of-life"
    }
  ],
  "searchQueries": [],
  "questionUrls": [],
  "answerUrls": [],
  "topicUrls": [],
  "spaceUrls": [],
  "profileUrls": [],
  "postUrls": [],
  "resultTypes": [
    "question",
    "answer",
    "comment",
    "profile",
    "profile_activity",
    "topic",
    "topic_post",
    "space",
    "space_feed_item",
    "entity_edge",
    "status",
    "run_manifest"
  ],
  "outputFormat": "normalized",
  "dedupeMode": "canonical",
  "onlyNewItems": false,
  "includeUnchanged": true,
  "stateStoreId": "",
  "outputFields": [],
  "includeFieldEvidence": true,
  "includeUnresolvedEdges": true,
  "relationshipTypes": [],
  "includeProfileEdges": false,
  "includeQuestionFollowerEdges": false,
  "includeAnswerUpvoterEdges": false,
  "includeSensitiveRelationshipData": false,
  "includeTargetMetadata": false,
  "includeRelationshipCounts": false,
  "includeSpaceRoleEdges": false,
  "includeSpaceContentEdges": true,
  "maxRelationshipItemsPerCollection": 500,
  "maxQuestions": 10,
  "maxAnswersPerQuestion": 5,
  "maxAnswers": 0,
  "includeQuestion": true,
  "includeAuthor": true,
  "includeAuthorSnapshot": false,
  "includeTopics": true,
  "includeSpaces": false,
  "includeComments": false,
  "includeEngagementBreakdown": true,
  "includeRelatedContent": false,
  "maxRelatedContent": 20,
  "topCommentsOnly": false,
  "commentSortOrder": "observed",
  "includeReplyGraph": false,
  "includeMedia": false,
  "includeFeedText": false,
  "includeOutboundLinks": false,
  "includeEntityGraph": false,
  "maxCommentsPerAnswer": 0,
  "maxCommentDepth": 20,
  "maxItems": 0,
  "maxGraphEdges": 1000,
  "maxScrollAttempts": 5,
  "maxLoadMoreAttempts": 0,
  "includeRawEvidence": false,
  "includeHtml": false,
  "maxHtmlBytes": 100000,
  "requestDelay": 1,
  "maxConcurrency": 1,
  "maxNavigationRetries": 2,
  "language": "auto",
  "redactSensitiveQueryParams": true,
  "rawEvidenceRetentionDays": 30,
  "maxRawEvidenceBytes": 100000,
  "maxItemsPerSource": 0,
  "searchDiscovery": "relatedOnly",
  "maxRelatedQuestions": 0,
  "searchResultsPerQuery": 0,
  "maxAnswerPages": 0,
  "maxTopicFeedPages": 0,
  "maxSpaceFeedBundles": 1,
  "includeCommentReplies": false,
  "includeQuoraPlusPreview": true,
  "includeProfileStats": true,
  "includeTopicStats": true,
  "includeSpaceStats": true,
  "includePostStats": true,
  "includeAnswerStats": true,
  "includeTopicFeed": false,
  "includeQuestionAudit": false,
  "includeProfileHistory": false,
  "maxProfileHistoryPages": 0,
  "maxRelationshipPages": 0
}
```

# Actor output Schema

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

All records from the run, in the default dataset.

# 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": "auto",
    "scrapeDepth": "detail",
    "startUrls": [
        {
            "url": "https://www.quora.com/What-is-the-meaning-of-life"
        }
    ],
    "outputFormat": "normalized",
    "dedupeMode": "canonical",
    "onlyNewItems": false,
    "includeUnchanged": true,
    "includeFieldEvidence": true,
    "includeUnresolvedEdges": true,
    "includeProfileEdges": false,
    "includeQuestionFollowerEdges": false,
    "includeAnswerUpvoterEdges": false,
    "includeSensitiveRelationshipData": false,
    "includeTargetMetadata": false,
    "includeRelationshipCounts": false,
    "includeSpaceRoleEdges": false,
    "includeSpaceContentEdges": true,
    "maxQuestions": 10,
    "maxAnswersPerQuestion": 5,
    "includeQuestion": true,
    "includeAuthor": true,
    "includeAuthorSnapshot": false,
    "includeTopics": true,
    "includeSpaces": false,
    "includeComments": false,
    "includeEngagementBreakdown": true,
    "includeRelatedContent": false,
    "topCommentsOnly": false,
    "includeReplyGraph": false,
    "includeMedia": false,
    "includeFeedText": false,
    "includeOutboundLinks": false,
    "includeEntityGraph": false,
    "maxCommentsPerAnswer": 0,
    "maxCommentDepth": 20,
    "maxGraphEdges": 1000,
    "includeRawEvidence": false,
    "includeHtml": false,
    "redactSensitiveQueryParams": true,
    "maxItemsPerSource": 0,
    "searchDiscovery": "relatedOnly",
    "maxRelatedQuestions": 0,
    "searchResultsPerQuery": 0,
    "maxAnswerPages": 0,
    "maxTopicFeedPages": 0,
    "maxSpaceFeedBundles": 1,
    "includeCommentReplies": false,
    "includeQuoraPlusPreview": true,
    "includeProfileStats": true,
    "includeTopicStats": true,
    "includeSpaceStats": true,
    "includePostStats": true,
    "includeAnswerStats": true,
    "includeTopicFeed": false,
    "includeQuestionAudit": false,
    "includeProfileHistory": false,
    "maxProfileHistoryPages": 0,
    "maxRelationshipPages": 0
};

// Run the Actor and wait for it to finish
const run = await client.actor("nimbryxo-studio/quora-question-answer-and-relationship-dataset").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": "auto",
    "scrapeDepth": "detail",
    "startUrls": [{ "url": "https://www.quora.com/What-is-the-meaning-of-life" }],
    "outputFormat": "normalized",
    "dedupeMode": "canonical",
    "onlyNewItems": False,
    "includeUnchanged": True,
    "includeFieldEvidence": True,
    "includeUnresolvedEdges": True,
    "includeProfileEdges": False,
    "includeQuestionFollowerEdges": False,
    "includeAnswerUpvoterEdges": False,
    "includeSensitiveRelationshipData": False,
    "includeTargetMetadata": False,
    "includeRelationshipCounts": False,
    "includeSpaceRoleEdges": False,
    "includeSpaceContentEdges": True,
    "maxQuestions": 10,
    "maxAnswersPerQuestion": 5,
    "includeQuestion": True,
    "includeAuthor": True,
    "includeAuthorSnapshot": False,
    "includeTopics": True,
    "includeSpaces": False,
    "includeComments": False,
    "includeEngagementBreakdown": True,
    "includeRelatedContent": False,
    "topCommentsOnly": False,
    "includeReplyGraph": False,
    "includeMedia": False,
    "includeFeedText": False,
    "includeOutboundLinks": False,
    "includeEntityGraph": False,
    "maxCommentsPerAnswer": 0,
    "maxCommentDepth": 20,
    "maxGraphEdges": 1000,
    "includeRawEvidence": False,
    "includeHtml": False,
    "redactSensitiveQueryParams": True,
    "maxItemsPerSource": 0,
    "searchDiscovery": "relatedOnly",
    "maxRelatedQuestions": 0,
    "searchResultsPerQuery": 0,
    "maxAnswerPages": 0,
    "maxTopicFeedPages": 0,
    "maxSpaceFeedBundles": 1,
    "includeCommentReplies": False,
    "includeQuoraPlusPreview": True,
    "includeProfileStats": True,
    "includeTopicStats": True,
    "includeSpaceStats": True,
    "includePostStats": True,
    "includeAnswerStats": True,
    "includeTopicFeed": False,
    "includeQuestionAudit": False,
    "includeProfileHistory": False,
    "maxProfileHistoryPages": 0,
    "maxRelationshipPages": 0,
}

# Run the Actor and wait for it to finish
run = client.actor("nimbryxo-studio/quora-question-answer-and-relationship-dataset").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": "auto",
  "scrapeDepth": "detail",
  "startUrls": [
    {
      "url": "https://www.quora.com/What-is-the-meaning-of-life"
    }
  ],
  "outputFormat": "normalized",
  "dedupeMode": "canonical",
  "onlyNewItems": false,
  "includeUnchanged": true,
  "includeFieldEvidence": true,
  "includeUnresolvedEdges": true,
  "includeProfileEdges": false,
  "includeQuestionFollowerEdges": false,
  "includeAnswerUpvoterEdges": false,
  "includeSensitiveRelationshipData": false,
  "includeTargetMetadata": false,
  "includeRelationshipCounts": false,
  "includeSpaceRoleEdges": false,
  "includeSpaceContentEdges": true,
  "maxQuestions": 10,
  "maxAnswersPerQuestion": 5,
  "includeQuestion": true,
  "includeAuthor": true,
  "includeAuthorSnapshot": false,
  "includeTopics": true,
  "includeSpaces": false,
  "includeComments": false,
  "includeEngagementBreakdown": true,
  "includeRelatedContent": false,
  "topCommentsOnly": false,
  "includeReplyGraph": false,
  "includeMedia": false,
  "includeFeedText": false,
  "includeOutboundLinks": false,
  "includeEntityGraph": false,
  "maxCommentsPerAnswer": 0,
  "maxCommentDepth": 20,
  "maxGraphEdges": 1000,
  "includeRawEvidence": false,
  "includeHtml": false,
  "redactSensitiveQueryParams": true,
  "maxItemsPerSource": 0,
  "searchDiscovery": "relatedOnly",
  "maxRelatedQuestions": 0,
  "searchResultsPerQuery": 0,
  "maxAnswerPages": 0,
  "maxTopicFeedPages": 0,
  "maxSpaceFeedBundles": 1,
  "includeCommentReplies": false,
  "includeQuoraPlusPreview": true,
  "includeProfileStats": true,
  "includeTopicStats": true,
  "includeSpaceStats": true,
  "includePostStats": true,
  "includeAnswerStats": true,
  "includeTopicFeed": false,
  "includeQuestionAudit": false,
  "includeProfileHistory": false,
  "maxProfileHistoryPages": 0,
  "maxRelationshipPages": 0
}' |
apify call nimbryxo-studio/quora-question-answer-and-relationship-dataset --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,nimbryxo-studio/quora-question-answer-and-relationship-dataset"
        }
    }
}
```

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/uAivkcIOWnHGsAnKT/builds/yJ2UZKFwANg4ScxlV/openapi.json