# Quora Search Scraper By Content Type & Language Portal (`scrapier/quora-search-scraper`) Actor

🔍 Quora Search Scraper extracts high-intent results from Quora searches—titles, answers, authors, stats & links—fast and reliable. Perfect for market research, content mining & lead generation. 🚀 Save time, find insights faster.

- **URL**: https://apify.com/scrapier/quora-search-scraper.md
- **Developed by:** [Scrapier](https://apify.com/scrapier) (community)
- **Categories:** Lead generation, Developer tools, Other
- **Stats:** 1 total users, 1 monthly users, 100.0% 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 Search Scraper — Content Type & Language Portal Targeting

Quora Search Scraper By Content Type & Language Portal turns any keyword into structured Quora data — questions, answers, user profiles, topics, or spaces, picked with a `searchType` selector, discovered on the localized Quora portal of your choice (English, Spanish, French, German, Italian, Portuguese, Hindi, Indonesian, Arabic) via a `language` selector. Paste direct Quora URLs too, for any of those page types. Every response is structured JSON — ready to pass directly to an LLM, index into a vector store, or feed a monitoring pipeline. No Quora login or cookies are required, and every row carries full engagement metrics plus the exact host and discovery method it came from.

### What is Quora Search Scraper By Content Type & Language Portal?

It is an Apify Actor that searches Quora by keyword — resolving each keyword to public Quora URLs via DuckDuckGo (with a Bing fallback) — and then renders those pages with a stealth browser to extract their embedded GraphQL data. A `searchType` input controls which entity type keyword discovery targets: questions, profiles, topics, spaces, or all types mixed. A `language` input retargets discovery at a localized Quora portal (`es.quora.com`, `fr.quora.com`, and seven others) instead of the default `www.quora.com`. You can also skip discovery entirely and paste direct Quora URLs — these are always scraped regardless of the `searchType` setting. No Quora account, login, or cookies are needed for any of it; the input schema has no credential or API-key field at all.

Under the hood, Quora renders its data as embedded GraphQL payloads — inside `window.ansFrontendGlobals.data.inlineQueryResults` on first load, and streamed from `gql_para_POST` responses while the page scrolls for more answers. The Actor captures both, so answer counts, upvotes, and full answer text come from Quora's own structured data rather than from parsing rendered HTML text, which is what keeps numbers accurate and answer text untruncated.

Key capabilities, read from the Actor's own input schema and source code:

- **Content-type-targeted discovery** — `searchType` = `question`, `profile`, `topic`, `space`, or `all`, instead of only ever finding questions
- **Language-portal discovery** — `language` = `en`, `es`, `fr`, `de`, `it`, `pt`, `hi`, `id`, or `ar`, issued as a `site:<lang>.quora.com` search so results come from that localized Quora domain
- **Discovery breadth control** — `maxDiscoveryResultsPerQuery` caps how many URLs a single keyword may surface, independent of the total row budget
- **Direct URL scraping** — questions, profiles, topics, and spaces, bulk-pasted
- **Full answer extraction** — complete answer text (not a preview), author name, credentials, upvotes, comments, shares, relative age, and an `is_ai_answer` flag
- **Automatic proxy escalation** — direct → Apify datacenter → Apify residential, sticky once escalated

### What data can you get with Quora Search Scraper By Content Type & Language Portal?

The Actor returns five row shapes in one dataset, each identified by its `content_type` field. Every field below is copied directly from the row-building functions in `src/parsers.py` — nothing paraphrased or renamed.

| Result Type | Extracted Fields | Primary Use Case |
| --- | --- | --- |
| `question` | `title`, `url`, `answer_count`, `follow_count`, `topics` | Mapping which questions exist for a topic and how much engagement each attracts |
| `answer` | `answer_text`, `answer_url`, `author_name`, `author_url`, `author_credentials`, `upvotes`, `comments_count`, `shares_count`, `answer_timestamp`, `is_ai_answer`, `question_title`, `question_url` | Full-text research, sentiment and expert-opinion analysis, LLM grounding |
| `profile` | `name`, `bio`, `credentials`, `profile_image_url`, `follower_count`, `following_count`, `answer_count`, `question_count`, `total_views` | Expert / lead discovery, influencer and community mapping |
| `topic` | `name`, `description`, `follower_count`, `question_count` | Sizing a subject area and finding its most-followed hubs |
| `space` | `name`, `description`, `follower_count`, `post_count`, `contributor_count` | Finding and sizing active Quora communities (Spaces) around a subject |

Every row also carries `content_type`, `source_url`, `scrape_timestamp`, and the two provenance columns `discovered_via` and `portal` (added uniformly in `src/main.py`, not in the per-type row builders). `question` and `answer` rows additionally carry `source_query` — the keyword that found them, blank for rows scraped from a pasted direct URL.

#### 🌐 Content type & language portal targeting

This is the capability the two closest competing Quora scrapers checked for this README (Apify Store, 26 July 2026) do not document: crawlerbros/quora-search-scraper's keyword search only ever surfaces question URLs — profile, topic, and space results are reachable only by pasting a direct URL, not by keyword; and neither its README nor memo23/Quora-Scraper-with-optional-login's documents any localized-portal search. Here, `searchType=profile` (or `topic`, `space`, `all`) points keyword discovery itself at that entity type, and `language=es` (or any of the eight other portals) issues the underlying search as `<keyword> site:es.quora.com`, so the URLs discovered — and the `portal` value stamped on each row — come from the localized Quora domain instead of `www.quora.com`. A profile row discovered this way looks like:

```json
{
  "content_type": "profile",
  "discovered_via": "profile",
  "portal": "es.quora.com",
  "name": "Maria Fernandez",
  "url": "https://es.quora.com/profile/Maria-Fernandez",
  "follower_count": 1840,
  "answer_count": 212,
  "scrape_timestamp": "2026-07-26T09:15:41+00:00"
}
```

`discovered_via` records which entity-type bucket a URL was sorted into during discovery (`question`, `profile`, `topic`, `space`, or `direct` for pasted URLs); `portal` records the exact host the row came from — so a single run mixing `searchQueries` and `directUrls` across languages stays fully traceable per row.

#### 💬 Full answer text with AI-answer detection

Answer rows carry the complete `answer_text` (Quora's rich-text sections flattened to plain text, not a truncated card preview) alongside `author_credentials`, `upvotes`, `comments_count`, `shares_count`, and a relative `answer_timestamp` (e.g. `"2y"`, `"4mo"`) read straight off Quora's own age format. The `is_ai_answer` boolean is set from Quora's own `isMachineAnswer` field, so AI-generated answers can be filtered out of research or training-data pipelines without guessing from the text itself.

### Why not build this yourself?

Quora does not publish a public search or content API for developers, so there is no official endpoint to compare this Actor against. Building a scraper against Quora directly means solving three problems this Actor already handles: the site sits behind Cloudflare, so plain HTTP requests get an interstitial challenge instead of data — this Actor renders pages with a stealth Chromium browser and automatically escalates from a direct connection to an Apify datacenter proxy, then to a residential proxy, sticking on whichever level clears the challenge. Quora's actual data lives in embedded GraphQL payloads (`window.ansFrontendGlobals.data.inlineQueryResults`) and in streamed `gql_para_POST` responses captured while scrolling — both undocumented and subject to change without notice, which is what `src/parsers.py` exists to isolate. And discovery itself has no search endpoint either — Quora's own search is not scriptable without a session, so this Actor discovers public URLs through DuckDuckGo (its JavaScript search app first, then its lighter no-JS HTML endpoint) and a Bing fallback, issuing each as a `<keyword> site:<portal-host>` query and sorting the results into question, profile, topic, and space buckets by URL shape. For `question`/`all` searches still short of the requested count, it tops up further by opening discovered topic pages and harvesting the question URLs embedded in their own GraphQL feeds. Maintaining all of that — proxy rotation, GraphQL parsing, and multi-engine, multi-bucket discovery — inside your own pipeline is ongoing work; here it is a `maxResults` number and a `Start` click.

### What's the difference between a Quora question scraper and a content-type Quora search scraper?

A Quora question scraper resolves a keyword to question pages and returns questions and answers — that is what "Quora search scraper" means for most tools on the Apify Store, including the closest competitor here. A content-type Quora search scraper instead lets the keyword search itself be aimed at a different entity type: profiles, topics, or spaces, not just questions. The distinction matters because the entity types carry different information — a question surfaces what people are asking, but a profile surfaces who is answering (their bio, credentials, and follower count), a topic surfaces how large and active a subject hub is, and a space surfaces which communities exist around it at all. A tool that can only turn a keyword into questions can't answer "who are the visible experts on this subject" or "which Quora Spaces cover this topic" without the reader manually hunting down URLs to paste in. Quora Search Scraper By Content Type & Language Portal returns both: set `searchType=question` (the default) for the classic question/answer behavior, or point it at `profile`, `topic`, `space`, or `all` to get the other entity types directly from a keyword, each arriving as its own `content_type` in the same dataset.

### How to scrape Quora with Quora Search Scraper By Content Type & Language Portal?

1. Open **Quora Search Scraper By Content Type & Language Portal** on its Apify Store listing and click **Try for free** to open it in the Apify Console.
2. Enter one or more keywords in `searchQueries`, and/or paste specific pages into `directUrls`.
3. Pick a `searchType` (`question`, `profile`, `topic`, `space`, or `all`) and a `language` portal, and set `maxDiscoveryResultsPerQuery` and `maxResults` to the volume you need.
4. Click **Start** and watch the real-time log — it reports each keyword searched, URLs found, and the running row total.
5. Open the **Output** tab, switch the view dropdown between **All Results**, **Answers**, **Questions**, **Profiles**, **Topics**, and **Spaces**, and export as JSON, CSV, or Excel.

```json
{
  "searchQueries": ["artificial intelligence"],
  "searchType": "profile",
  "language": "es",
  "maxResults": 100
}
```

#### Running multiple queries in one job

`searchQueries` is an array (a `stringList` input in the Apify Console — one keyword per line), so a single run can search any number of keywords, and `directUrls` accepts the same bulk, one-per-line format for pasted pages. `maxResults` is a **shared** budget across the whole run, not a per-keyword limit: `src/main.py` tracks a running `total` and stops pulling new rows the moment it is reached, whichever keyword or URL is being processed at that instant. The Actor does not expose a documented concurrency setting — keywords and URLs are processed sequentially against the shared budget.

### ⬇️ Input

Every parameter is optional — `required: []` in the input schema — but at least one of `searchQueries` or `directUrls` must be set, or the run logs a warning and exits immediately without scraping anything. There is no credential, cookie, or API-key field anywhere in the schema.

| Parameter | Required | Type | Description | Example Value |
| --- | --- | --- | --- | --- |
| `searchQueries` | No | array | Keywords to search on Quora. Each keyword discovers relevant Quora URLs (via DuckDuckGo, Bing fallback) and scrapes them. No Quora login needed. | `["python programming"]` |
| `searchType` | No | string | Which public Quora page type keyword discovery should target. Enum: `question` (default), `profile`, `topic`, `space`, `all`. Direct URLs are always scraped regardless of this setting. | `"profile"` |
| `language` | No | string | Quora language portal to search — discovers content from the localized site (e.g. `es.quora.com` for Spanish). Enum: `en` (default), `es`, `fr`, `de`, `it`, `pt`, `hi`, `id`, `ar`. | `"es"` |
| `maxDiscoveryResultsPerQuery` | No | integer | How many public Quora URLs each keyword may discover before page data is collected — controls discovery breadth separately from the total row cap. Default `50`, minimum `1`, maximum `50`. | `50` |
| `directUrls` | No | array | Paste any Quora URLs directly — questions, profiles, topics, or spaces. Supports bulk input (one per line). | `["https://www.quora.com/What-is-Python-used-for"]` |
| `maxResults` | No | integer | Total number of result rows to collect — across all keywords and URLs combined. Default `10`, minimum `1`, maximum `50000`. | `200` |
| `proxyConfiguration` | No | object | Optional Apify Proxy configuration used as the mid-tier (datacenter) network. Residential is applied automatically as the final fallback. Default `{"useApifyProxy": true}`. | `{"useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"]}` |

Example input:

```json
{
  "searchQueries": ["artificial intelligence", "machine learning"],
  "searchType": "profile",
  "language": "es",
  "maxDiscoveryResultsPerQuery": 50,
  "directUrls": ["https://www.quora.com/What-is-Python-used-for"],
  "maxResults": 200,
  "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"] }
}
```

**Common pitfall:** `maxDiscoveryResultsPerQuery` (max `50`) and `maxResults` (max `50000`) cap two different things. Raising `maxResults` alone does not make a single keyword discover more URLs — discovery per keyword is capped at `50` regardless. To collect more than roughly 50 results, add more keywords to `searchQueries` or more pages to `directUrls`; `maxResults` then governs how much of that combined pool is actually scraped.

### ⬆️ Output

Results are typed, normalized JSON rows written live to the Actor's default dataset as they are scraped, plus mirrored into per-content-type alias datasets (visible as the **Answers**, **Questions**, **Profiles**, **Topics**, and **Spaces** views in the Output tab, alongside **All Results**). Every run supports the Apify platform's standard dataset exports — JSON, CSV, Excel, and the other formats the Output tab offers.

Billing runs on Apify's pay-per-event model against a single event, `row_result`. Each row is pushed to the default dataset through one `push_data(row, charged_event_name="row_result")` call — one charge per row, with no separate accounting or billing call layered on top. The per-content-type alias datasets (the Answers/Questions/Profiles/Topics/Spaces views) are mirrored copies of the same already-charged rows, not additional billed events.

#### Scraped results

```json
[
  {
    "content_type": "question",
    "discovered_via": "question",
    "portal": "www.quora.com",
    "title": "What is Python primarily used for?",
    "url": "https://www.quora.com/What-is-Python-primarily-used-for",
    "answer_count": 128,
    "follow_count": 342,
    "topics": ["Python (programming language)", "Software Development"],
    "source_url": "https://www.quora.com/What-is-Python-primarily-used-for",
    "source_query": "python programming",
    "scrape_timestamp": "2026-07-26T09:14:02+00:00"
  },
  {
    "content_type": "answer",
    "discovered_via": "question",
    "portal": "www.quora.com",
    "title": "What is Python primarily used for?",
    "url": "https://www.quora.com/What-is-Python-primarily-used-for/answer/Jane-Doe-123",
    "answer_text": "Python is widely used for web development, data science, automation and scripting because of its readable syntax and large ecosystem of libraries.",
    "answer_url": "https://www.quora.com/What-is-Python-primarily-used-for/answer/Jane-Doe-123",
    "author_name": "Jane Doe",
    "author_url": "https://www.quora.com/profile/Jane-Doe-123",
    "author_credentials": "Software Engineer",
    "upvotes": 214,
    "comments_count": 12,
    "shares_count": 6,
    "answer_timestamp": "1y",
    "is_ai_answer": false,
    "question_title": "What is Python primarily used for?",
    "question_url": "https://www.quora.com/What-is-Python-primarily-used-for",
    "source_url": "https://www.quora.com/What-is-Python-primarily-used-for",
    "source_query": "python programming",
    "scrape_timestamp": "2026-07-26T09:14:05+00:00"
  },
  {
    "content_type": "profile",
    "discovered_via": "profile",
    "portal": "es.quora.com",
    "title": "Maria Fernandez",
    "name": "Maria Fernandez",
    "url": "https://es.quora.com/profile/Maria-Fernandez",
    "bio": "Ingeniera de datos especializada en machine learning.",
    "credentials": "Ingeniera de Datos",
    "profile_image_url": "https://qph.cf2.quoracdn.net/main-thumb-example.jpeg",
    "follower_count": 1840,
    "following_count": 96,
    "answer_count": 212,
    "question_count": 14,
    "total_views": 980000,
    "source_url": "https://es.quora.com/profile/Maria-Fernandez",
    "scrape_timestamp": "2026-07-26T09:15:41+00:00"
  },
  {
    "content_type": "topic",
    "discovered_via": "topic",
    "portal": "www.quora.com",
    "title": "Python (programming language)",
    "name": "Python (programming language)",
    "url": "https://www.quora.com/topic/Python-programming-language-1",
    "description": "Python is a high-level, general-purpose programming language.",
    "follower_count": 1620000,
    "question_count": 48210,
    "source_url": "https://www.quora.com/topic/Python-programming-language-1",
    "scrape_timestamp": "2026-07-26T09:16:10+00:00"
  },
  {
    "content_type": "space",
    "discovered_via": "space",
    "portal": "www.quora.com",
    "title": "Data Science Community",
    "name": "Data Science Community",
    "url": "https://www.quora.com/q/data-science-community",
    "description": "A space for data scientists to share research, tools and career advice.",
    "follower_count": 104300,
    "post_count": 3820,
    "contributor_count": 219,
    "source_url": "https://www.quora.com/q/data-science-community",
    "scrape_timestamp": "2026-07-26T09:16:44+00:00"
  }
]
```

### How can I use the data extracted with Quora Search Scraper By Content Type & Language Portal?

- **📊 Content researchers and SEO teams:** run `searchType=question` against a subject to build a content-gap map from `title`, `answer_count`, and `topics` — questions with high `follow_count` but a thin `answer_count` flag under-served demand worth writing or answering for.
- **🤖 AI engineers and LLM developers:** an agent issues a query, receives structured `answer_text`/`question_title` JSON, and passes it to the model as grounded context — filtering out `is_ai_answer: true` rows first keeps the context set to human-written source material rather than Quora's own AI answers.
- **📈 Market researchers:** run `searchType=all` across a keyword set and language portal to measure share-of-voice — how many questions, active experts (`profile` rows), and communities (`space` rows) exist for a topic in each market, and how that compares across the nine language portals.
- **🧭 Product teams:** use `profile` rows' `credentials` and `bio` fields to find and validate domain experts already discussing a category, and `topic`/`space` `follower_count` and `question_count`/`post_count` to size where in a subject area to engage first.
- **🗂️ Community and social listening teams:** track `space` rows' `contributor_count` and `post_count` alongside `topic` rows' `follower_count` to see which Quora communities around a brand or category are actually active, not just nominally followed.

### 🌐 How do you monitor content type and language portal coverage over time?

Monitoring here means re-running the same keyword set on a schedule and diffing the results, not a single one-off pull. Because every row carries `scrape_timestamp`, `discovered_via`, and `portal`, two runs of the same `searchQueries` can be compared directly: a new `url` appearing in a later run's `question` rows is new content; a rising `answer_count`, `upvotes`, or `follower_count` on a `url` seen in both runs is a live engagement signal; a `profile` row's `follower_count` climbing across runs tracks a specific author's growing reach.

The specific fields worth diffing between runs are `answer_count` and `follow_count` on `question` rows, `upvotes` and `comments_count` on `answer` rows, and `follower_count` on `profile`, `topic`, and `space` rows. A practical workflow: schedule a run across a fixed keyword set (and, if you track a specific market, a fixed `language`) using the Apify Console's **Schedule** feature, store each run's dataset, and compare the latest export against the previous one on those fields — alerting when a tracked `url`'s `upvotes` or `follower_count` crosses a threshold you set. Because `discovered_via` and `portal` are stamped on every row, the same diffing loop also works per language portal — running the identical keyword set with only `language` changed lets you compare how a topic's coverage and engagement differ between, say, the English and Spanish portals over the same period. The Actor itself has no built-in diffing or alerting — it produces the comparable rows; the schedule and the diff live in the Apify Console or in whatever pipeline consumes the exported dataset.

### Integrate Quora Search Scraper By Content Type & Language Portal and automate your workflow

Quora Search Scraper By Content Type & Language Portal works with any language or tool that can send an HTTP request, through the Apify API.

#### REST API with Python

```python
import requests

TOKEN = "<APIFY_TOKEN>"
ACTOR_ID = "<YOUR_USERNAME>~quora-search-scraper-by-content-type-language-portal"
url = f"https://api.apify.com/v2/acts/{ACTOR_ID}/run-sync-get-dataset-items"

payload = {
    "searchQueries": ["artificial intelligence"],
    "searchType": "profile",
    "language": "es",
    "maxResults": 50,
}

resp = requests.post(url, json=payload, params={"token": TOKEN})
resp.raise_for_status()
rows = resp.json()          # list of row dicts, one per result
print(rows[0]["content_type"], rows[0].get("name") or rows[0].get("title"))
```

`run-sync-get-dataset-items` blocks until the run finishes and returns the dataset directly, which suits short runs. For a `maxResults` large enough to run for a while, start the run asynchronously against `POST /v2/acts/{ACTOR_ID}/runs` instead, poll `GET /v2/actor-runs/{runId}` until its status is `SUCCEEDED`, then fetch `GET /v2/datasets/{defaultDatasetId}/items` — the same pattern the Apify Console itself uses, and the one the official `apify-client` Python package wraps for you if you'd rather not poll manually.

#### Scheduled monitoring and delivery

The Actor has no built-in webhook or push-delivery feature of its own; recurring collection is handled through the Apify platform's own **Schedules** (Apify Console → Schedules), which trigger a run on a cron-style interval with a saved input, and through Apify's account-level **Webhooks**, which can notify an external endpoint when a run finishes so a pipeline can pull the finished dataset.

### Is it legal to scrape Quora search results?

Scraping publicly accessible Quora pages is generally lawful — courts have held that accessing data a website makes available to any visitor without a login is not unauthorized access under U.S. computer-crime law (*hiQ Labs, Inc. v. LinkedIn Corp.*, 938 F.3d 985, 9th Cir. 2019). This Actor requires no Quora login, so it only ever collects what a logged-out visitor can already see. Because Quora rows include personal data about real people — author names, bios, and profile details on `profile` and `answer` rows — data-protection regimes such as GDPR and CCPA apply to how that data is stored and used, separately from whether accessing it was authorized; scraping for AI training and scraping for operational monitoring carry different risk profiles under those regimes. Quora's own Terms of Service govern what its content may be used for regardless of technical accessibility. Consult your legal team for commercial use cases involving bulk data storage.

### ❓ Frequently asked questions

#### How does the `language` parameter change what this Actor returns?

`language` retargets keyword discovery at a specific Quora portal — `en` (default, `www.quora.com`), `es`, `fr`, `de`, `it`, `pt`, `hi`, `id`, or `ar` — by issuing the discovery search as `<keyword> site:<lang>.quora.com`. It does not translate results or filter by content language beyond what that portal itself serves; the `portal` field on every row records the exact host the row was found on.

#### What does the `searchType` parameter control?

It picks which entity type keyword discovery targets: `question` (default), `profile`, `topic`, `space`, or `all` for every type interleaved together. It only affects keyword-driven discovery — URLs pasted into `directUrls` are always scraped regardless of `searchType`.

#### How does this Actor handle Quora's anti-bot measures?

Quora sits behind Cloudflare. Pages are rendered with a stealth Chromium browser (via `playwright-stealth`), and the Actor starts with a direct connection, escalating to an Apify datacenter proxy and then a residential proxy automatically if it detects a block, sticking on whichever level clears it for the rest of the run. Each page navigation is retried up to 3 times (60-second navigation timeout per attempt), and once the residential rung is reached, an extra 3 retries are granted specifically at that level before an individual URL is given up on. Discovery itself follows the same escalation ladder and retries up to 3 additional times over residential if a search round returns nothing.

#### Does this Actor extract profiles, topics, and spaces, not just questions?

Yes — set `searchType` to `profile`, `topic`, or `space` to point keyword discovery directly at that entity type, or `all` to interleave all four. Each arrives as its own `content_type` value in the dataset, with the fields listed in the data-coverage table above. Direct URLs to any of these page types are scraped regardless of `searchType`.

#### How many results does this Actor return per query?

`maxResults` (default `10`, maximum `50000`) is the total row ceiling across the whole run, shared by every keyword and direct URL. Within that, a single keyword can discover at most `maxDiscoveryResultsPerQuery` URLs (default and maximum `50`) before those URLs are scraped.

#### How do I use this Actor to monitor Quora coverage for a keyword over time?

Schedule a run across a fixed keyword set (and `language`, if market-specific) using the Apify Console's Schedule feature, and compare each run's `answer_count`, `upvotes`, `comments_count`, and `follower_count` against the previous run's export on matching `url` values to catch new content or rising engagement.

#### Does this Actor work with Claude, ChatGPT, and AI agent frameworks?

It is not exposed through an MCP server, but it is callable as a standard HTTP endpoint through the Apify API by any agent framework that can issue a request — an agent calls the run endpoint, receives structured JSON rows back, and can pass `answer_text` or profile fields to the model as grounded context.

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

As observed on the Apify Store on 26 July 2026: crawlerbros/quora-search-scraper's keyword search surfaces only question URLs, with profile, topic, and space scraping available solely via pasted direct URLs, and its README does not document a language-portal search. memo23/Quora-Scraper-with-optional-login requires the user to export and paste their own Quora account cookies to access search results at all. This Actor needs no login or cookies for either discovery or scraping, and lets keyword discovery itself target profiles, topics, or spaces via `searchType`, and a localized Quora portal via `language`.

#### Can I use this Actor without managing proxies or a Quora account?

Yes. No Quora account, login, or cookies are needed anywhere in the input schema. Apify Proxy is optional and preconfigured (`proxyConfiguration` defaults to `{"useApifyProxy": true}`); the Actor manages the direct-to-datacenter-to-residential escalation itself, so you only need to leave Apify Proxy enabled for the automatic fallback to work.

#### Do all language portals return results for every keyword?

Not necessarily — a localized portal only returns as much as Quora has publicly indexed in that language for the keyword, so narrow keywords in smaller portals can return fewer results than English. If discovery finds nothing for a keyword after exhausting the proxy ladder and retries, no row is fabricated for it — it is simply skipped, and the run's log and final `content_type` breakdown reflect the real count collected.

#### Can this Actor access private or Quora+ paywalled content?

No. Since the input schema has no login, cookie, or credential field, the Actor only ever renders Quora pages as a logged-out, anonymous visitor would see them — the same public embedded data any browser loads. Content gated behind a Quora account or a Quora+ subscription is not reachable.

#### What happens if Quora blocks every request during a run?

The run still finishes rather than crashing. If the proxy ladder and residential retries are exhausted without clearing a block, the affected keyword or URL is skipped and logged as a warning; if the entire run ends with zero rows collected, the final log line suggests enabling the Apify `RESIDENTIAL` proxy group explicitly in `proxyConfiguration`.

### 💬 Your feedback

Found a bug or a field that doesn't match what's on the page? Let us know through the Issues tab on this Actor's Apify Console page, or message Scrapier support directly — reports like these keep the parser aligned with Quora's actual markup.

# Actor input Schema

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

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

## `searchType` (type: `string`):

Which public Quora page type keyword discovery should target: questions ❓ (default), user profiles 👤, topics 🏷️, spaces 🪐 — or all types mixed. Example: searchType=profile returns only profile rows for each keyword. Direct URLs are always scraped regardless of this setting.

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

Quora language portal to search — discovers content from the localized site (e.g. es.quora.com for Spanish). Example: language=es finds Spanish-language Quora URLs. Default is English (www.quora.com).

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

How many public Quora URLs each keyword may discover before page data is collected — controls discovery breadth separately from the total row cap. Example: 50 keywords-wide, then capped by Maximum Results. Default is 50.

## `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 — across all keywords and URLs combined. Want 60, 200 or 500 rows? Set exactly that. ✅

## `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"
  ],
  "searchType": "question",
  "language": "en",
  "maxDiscoveryResultsPerQuery": 50,
  "directUrls": [],
  "maxResults": 10,
  "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"
    ],
    "searchType": "question",
    "language": "en",
    "maxDiscoveryResultsPerQuery": 50,
    "directUrls": [],
    "maxResults": 10,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapier/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"],
    "searchType": "question",
    "language": "en",
    "maxDiscoveryResultsPerQuery": 50,
    "directUrls": [],
    "maxResults": 10,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

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

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/RpH0WiVksLP6anQiy/builds/ND9hdUPFMMmmfWFED/openapi.json