# Quora Search Scraper With Author Lead Enrichment (`api-empire/quora-search-scraper`) Actor

🔎 Quora Search Scraper extracts Quora search results and relevant post data fast. 🚀 Perfect for lead gen, market research & content insights. 📊 Save time, scale discovery, and build smarter datasets. 🤖 Get accurate Quora intel effortlessly.

- **URL**: https://apify.com/api-empire/quora-search-scraper.md
- **Developed by:** [API Empire](https://apify.com/api-empire) (community)
- **Categories:** Lead generation, Other, Developer tools
- **Stats:** 11 total users, 3 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.99 / 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.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

### Quora Search Scraper — Extract Answers, Questions and Author Leads

Quora Search Scraper With Author Lead Enrichment searches Quora by keyword or direct URL and returns questions, answers, profiles, topics and spaces — then opens every distinct answer author's public profile and turns them into a deduplicated `author_lead` row with bio, credentials, follower/answer reach and a computed lead score. Every response is typed, normalized JSON — no HTML, no selectors, no login required. Read on for the exact input parameters, every output field the Actor pushes, and how the author-enrichment pass is billed.

### What is Quora Search Scraper With Author Lead Enrichment?

Quora Search Scraper With Author Lead Enrichment is an Apify Actor that turns a Quora keyword search or a list of direct Quora URLs into structured rows for six content types: questions, answers, profiles, topics, spaces, and a sixth derived type — `author_lead`. No Quora account or login is required; every field returned is already visible to an anonymous visitor. The Actor is not reachable through an MCP server — it runs as a standard Apify Actor, callable through the Apify Console, API, or SDK.

- Scrape Quora **answers and questions** discovered from a keyword search (via DuckDuckGo, with a Bing fallback)
- Scrape **profiles, topics and spaces** from pasted Quora URLs
- Turn every distinct answer **author into a lead**: bio, credentials, follower/following/answer/question counts, total views, a computed `lead_score`, and links pulled from the bio
- Export as JSON, CSV, Excel or XML from the Apify dataset
- No proxy management required — the Actor climbs an automatic proxy ladder on its own

### What data does Quora Search Scraper With Author Lead Enrichment collect?

The Actor returns six distinct row shapes in one dataset, distinguished by a `content_type` field: `question`, `answer`, `profile`, `topic`, `space`, and `author_lead`.

| Data Type | Key Fields | JSON Field Names |
| --- | --- | --- |
| Answers | Answer text, upvotes, author, comment/share counts | `answer_text`, `upvotes`, `author_name`, `comments_count`, `shares_count` |
| Questions | Title, answer count, followers, topics | `title`, `answer_count`, `follow_count`, `topics` |
| Profiles | Name, bio, credentials, reach | `name`, `bio`, `credentials`, `follower_count`, `total_views` |
| Author leads | Bio, credentials, reach, computed lead score, bio links | `bio`, `credentials`, `lead_score`, `extracted_links`, `answers_seen_in_run` |
| Topics | Name, description, follower/question counts | `name`, `description`, `follower_count`, `question_count` |
| Spaces | Name, description, follower/post/contributor counts | `name`, `description`, `post_count`, `contributor_count` |

#### 🧲 Need more Quora data?

If you need Quora content from non-English portals, the same account publishes **Quora Scraper By Language Portal**, which scrapes questions, answers, profiles, topics and spaces from 24 localized Quora portals (es/fr/de/pt/hi/ar and more) with optional AI translation to English. This Actor stays keyword- and English-portal-focused, with its differentiator being the author lead enrichment pass.

### Why not build this yourself?

Quora does not publish a general-purpose public API that returns search results or question/answer content to anonymous callers, so scraping it yourself means solving three problems before you extract a single row.

First, Quora sits behind Cloudflare — a plain HTTP client gets an interstitial challenge page, not content. You need a real, stealth-patched Chromium browser that renders JavaScript and waits out the challenge. Second, Quora's data isn't in clean HTML — it's embedded as GraphQL payloads inside `window.ansFrontendGlobals.data.inlineQueryResults`, and more answers arrive via a streaming `gql_para_POST` endpoint as the page scrolls. You have to capture both the inline payload and the network responses, then walk an unstable nested structure to find `Answer`, `Question` and `User` nodes by `__typename`. Third, blocked or datacenter-flagged requests need a retry and proxy-escalation strategy, or your run returns zero rows the moment Quora pushes back.

This Actor does all three: stealth browser rendering, dual-source GraphQL extraction (inline script tags plus captured network responses), and an automatic DIRECT → DATACENTER → RESIDENTIAL proxy ladder that only climbs when needed and sticks once escalated.

### 🧲 Why do developers and teams scrape Quora and enrich its authors?

#### 🤖 For AI engineers and agent builders

Quora's Q\&A pairs are dense, topical training and retrieval data. An AI engineer building a RAG pipeline can index `answer_text` alongside `question_title` and `topics` per row, then use `author_credentials` as a lightweight authority signal when ranking retrieved passages. Because every row is typed JSON with stable field names, it drops straight into a vector store or an agent's tool-call response — no HTML stripping or answer-length truncation to work around first.

#### 📈 For sales and lead-generation teams

The author-lead pass is built for this: every distinct expert who answered a question in your niche becomes one deduplicated `author_lead` row with `bio`, `credentials`, `follower_count`, `total_views`, a computed `lead_score`, and `extracted_links` pulled from their bio for outreach. A team selling into "SaaS pricing" or "supply chain software" can search those keywords, skip building a scraper, and get a ranked list of people who publicly demonstrated expertise — with no email field, since Quora exposes none.

#### 🔬 For researchers and analysts

Public sentiment and expertise distribution on a topic are visible in the answer set itself: `upvotes`, `comments_count`, `answer_timestamp` and `is_ai_answer` let a researcher separate high-signal human answers from AI-generated ones and track how a topic's public discourse ages. Because `authorFilter` can pin the run to one expert, a researcher can also track a single public figure's answer history across many keyword searches in one run.

#### 🛠️ For developers building data products

`maxResults` scales up to 50,000 content rows in a single run, and `directUrls` accepts bulk pasted Quora links, so a developer can build a scheduled Quora-monitoring pipeline (via an Apify schedule) that feeds a product — a competitor-intelligence dashboard, an expert-directory tool, or a content-gap tracker — without re-solving Quora's anti-bot layer on every deploy.

### How to scrape Quora and enrich author leads (step by step)

1. Open **Quora Search Scraper With Author Lead Enrichment** on the Apify Store and click **Try for free**
2. Provide at least one of `searchQueries` (keywords) or `directUrls` (Quora question/profile/topic/space links) — both are optional individually, but the Actor does nothing if both are empty
3. Set `maxResults` to the total number of content rows you want (default `10`), and leave `scrapeAuthorProfiles` on (default) if you want the author-lead pass
4. Click **Start** — no Apify token setup is required beyond having an Apify account, since the Actor uses your account's proxy allowance
5. Open the **Output** tab, switch the view dropdown between **All Results**, **Author Leads**, **Answers**, **Questions**, **Profiles**, **Topics** and **Spaces**, and export as JSON, CSV, Excel or XML

#### What to do when Quora changes its structure

The Actor reads Quora's own embedded GraphQL payloads rather than CSS selectors, so a visual redesign generally does not break it — a selector-based scraper would need updating on every layout change, this one only needs updating if Quora renames the underlying GraphQL fields. The scraper is maintained and the output schema (field names and types) stays stable on your end. No specific turnaround time is promised.

### ⬇️ Input

None of the parameters are required — but the Actor logs a warning and exits with zero rows if both `searchQueries` and `directUrls` are empty.

| Parameter | Required | Type | Description | Example Value |
| --- | --- | --- | --- | --- |
| `searchQueries` | No | array | Keywords to search on Quora. Each keyword discovers relevant Quora question URLs (via DuckDuckGo, Bing fallback) and scrapes them. No Quora login needed. | `["what is python used for"]` |
| `directUrls` | No | array | Paste any Quora URLs directly — questions, profiles, topics or spaces. Supports bulk input (one per line). | `["https://www.quora.com/profile/Jane-Doe-123"]` |
| `maxResults` | No | integer | Total number of CONTENT rows (answers/questions/profiles/topics/spaces) to collect across all keywords and URLs combined. Default `10`. Minimum `1`, maximum `50000`. Author-lead rows are added on top of this cap — one per distinct answer author. | `10` |
| `scrapeAuthorProfiles` | No | boolean | On: for every distinct answer author found, open their public profile and emit an enriched `author_lead` row. Off: only the author name stays on each answer. Default `true`. | `true` |
| `authorFilter` | No | string | Only keep answers and leads written by this author (Quora display name or profile slug). Matched client-side against author name/profile URL. Leave empty for all authors. | `"Jane Doe"` |
| `location` | No | string | Biases keyword discovery toward a location (e.g. "London") by appending it to the search query text. Does NOT filter authors by geography — Quora exposes no reliable author location. Leave empty for global search. | `"New York"` |
| `aiEnhancement` | No | boolean | OFF by default. When on AND an API key is supplied, each author lead also gets `ai_expertise` and `ai_intent` inferred from its public bio and credentials. On failure or without a key these fields stay `null`. | `false` |
| `aiModel` | No | string | AI provider/model for `aiEnhancement`. Provider is auto-detected from the name prefix. Default `"claude-haiku-4-5"`. Enum: `claude-haiku-4-5`, `claude-sonnet-5`, `claude-opus-4-8`, `gpt-4o-mini`, `gpt-4o`, `gpt-4.1-mini`, `o3-mini`, `gemini-2.0-flash-lite`, `gemini-2.0-flash`, `gemini-2.5-flash`, `grok-3-mini`, `deepseek-chat`, `sonar`, `mistral-small-latest`. | `"claude-haiku-4-5"` |
| `aiApiKey` | No | string (secret) | Provider API key for AI enrichment. Kept secret by the input editor. Falls back to the matching provider environment variable if left empty (`ANTHROPIC_API_KEY` / `OPENAI_API_KEY` / `GEMINI_API_KEY` / `XAI_API_KEY` / `DEEPSEEK_API_KEY` / `PERPLEXITY_API_KEY` / `MISTRAL_API_KEY`). | `""` |
| `proxyConfiguration` | No | object | Apify Proxy configuration used as the mid-tier (datacenter) rung. Residential is applied automatically as the final fallback. Default `{"useApifyProxy": true}`. | `{"useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"]}` |

#### Example input

```json
{
  "searchQueries": ["what is python used for", "best CRM for startups"],
  "directUrls": ["https://www.quora.com/topic/Python-programming-language"],
  "maxResults": 200,
  "scrapeAuthorProfiles": true,
  "authorFilter": "",
  "location": "",
  "aiEnhancement": false,
  "aiModel": "claude-haiku-4-5",
  "aiApiKey": "",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
```

⚠️ Common pitfall: `authorFilter` only filters `answer` and `author_lead` rows — `question`, `profile`, `topic` and `space` rows from your search or direct URLs are never filtered by author, since those content types don't carry an author field to match against.

### ⬆️ Output

Every row lands in the default dataset with a `content_type` discriminator, plus common bookkeeping fields (`source_url`, `scrape_timestamp`, and for search-driven rows, `source_query`). Alongside the default dataset, each content type is mirrored into its own named dataset view (`answers`, `questions`, `profiles`, `topics`, `spaces`, `author_leads`) so you can pull one type cleanly without filtering. Export as JSON, CSV, Excel, XML, RSS or HTML from any dataset view.

#### Scraped author leads

The core output of this variant — one row per distinct answer author, deduplicated across every keyword and URL in the run.

```json
{
  "content_type": "author_lead",
  "is_lead": true,
  "title": "Jane Doe",
  "name": "Jane Doe",
  "url": "https://www.quora.com/profile/Jane-Doe-123",
  "bio": "Data engineer, 8 years building ETL pipelines. Writing about Python and dbt.",
  "credentials": "Data Engineer at Acme Corp",
  "profile_image_url": "https://qph.cf2.quoracdn.net/...jpg",
  "follower_count": 4210,
  "following_count": 88,
  "answer_count": 312,
  "question_count": 9,
  "total_views": 1850000,
  "lead_score": 71.4,
  "answers_seen_in_run": 3,
  "extracted_links": ["https://janedoe.dev", "@janedoedata"],
  "matched_keyword": "what is python used for",
  "ai_expertise": null,
  "ai_intent": null,
  "source_url": "https://www.quora.com/profile/Jane-Doe-123",
  "scrape_timestamp": "2026-07-25T14:02:11.483210+00:00"
}
```

`ai_expertise` and `ai_intent` stay `null` unless `aiEnhancement` is `true` and a usable API key was supplied — they are never fabricated on failure. `lead_score` is a computed 0–100 value derived from log-scaled follower count, total views and answer count (not a Quora field). `follower_count`, `following_count`, `answer_count`, `question_count` and `total_views` are `null` — not zero — when the author's profile page could not be opened or returned no usable node, so a failed enrichment is visibly distinct from a real zero.

#### Scraped answers

```json
{
  "content_type": "answer",
  "title": "What is Python used for?",
  "url": "https://www.quora.com/What-is-Python-used-for/answer/Jane-Doe-123",
  "answer_text": "Python is used for web backends, data analysis, automation scripting...",
  "answer_url": "https://www.quora.com/What-is-Python-used-for/answer/Jane-Doe-123",
  "author_name": "Jane Doe",
  "author_url": "https://www.quora.com/profile/Jane-Doe-123",
  "author_credentials": "Data Engineer at Acme Corp",
  "upvotes": 128,
  "comments_count": 6,
  "shares_count": 14,
  "answer_timestamp": "2y",
  "is_ai_answer": false,
  "question_title": "What is Python used for?",
  "question_url": "https://www.quora.com/What-is-Python-used-for",
  "source_url": "https://www.quora.com/What-is-Python-used-for",
  "source_query": "what is python used for",
  "scrape_timestamp": "2026-07-25T14:01:47.100022+00:00"
}
```

#### Scraped questions

```json
{
  "content_type": "question",
  "title": "What is Python used for?",
  "url": "https://www.quora.com/What-is-Python-used-for",
  "answer_count": 214,
  "follow_count": 3021,
  "topics": ["Python (programming language)", "Computer Programming"],
  "source_url": "https://www.quora.com/What-is-Python-used-for",
  "source_query": "what is python used for",
  "scrape_timestamp": "2026-07-25T14:01:46.902110+00:00"
}
```

#### Scraped profiles, topics and spaces

Direct profile/topic/space URLs pasted into `directUrls` return one row each, structurally distinct from an `author_lead` — a `profile` row is a plain snapshot of whatever page you pointed at, while an `author_lead` row only ever comes from the enrichment pass over answer authors and additionally carries `lead_score`, `answers_seen_in_run`, `extracted_links` and `matched_keyword`.

```json
{
  "content_type": "profile",
  "title": "Jane Doe",
  "name": "Jane Doe",
  "url": "https://www.quora.com/profile/Jane-Doe-123",
  "bio": "Data engineer, 8 years building ETL pipelines.",
  "credentials": "Data Engineer at Acme Corp",
  "profile_image_url": "https://qph.cf2.quoracdn.net/...jpg",
  "follower_count": 4210,
  "following_count": 88,
  "answer_count": 312,
  "question_count": 9,
  "total_views": 1850000,
  "source_url": "https://www.quora.com/profile/Jane-Doe-123",
  "scrape_timestamp": "2026-07-25T14:03:02.771003+00:00"
}
```

```json
{
  "content_type": "topic",
  "title": "Python (programming language)",
  "name": "Python (programming language)",
  "url": "https://www.quora.com/topic/Python-programming-language",
  "description": "Python is a general-purpose, high-level programming language.",
  "follower_count": 89210,
  "question_count": 41200,
  "source_url": "https://www.quora.com/topic/Python-programming-language",
  "scrape_timestamp": "2026-07-25T14:03:19.552017+00:00"
}
```

```json
{
  "content_type": "space",
  "title": "Data Engineering Weekly",
  "name": "Data Engineering Weekly",
  "url": "https://www.quora.com/q/data-engineering-weekly",
  "description": "Curated posts on pipelines, warehousing and dbt.",
  "follower_count": 3105,
  "post_count": 412,
  "contributor_count": 18,
  "source_url": "https://www.quora.com/q/data-engineering-weekly",
  "scrape_timestamp": "2026-07-25T14:03:34.118820+00:00"
}
```

#### Field groups across the six content types

Every row starts with `content_type` (one of `question`, `answer`, `profile`, `topic`, `space`, `author_lead`) so a single dataset export can be split back into its parts with one filter.

**Identity fields** — `title`/`name`, `url` — appear on every row and are always absolute `https://www.quora.com/...` links, never relative paths, since the Actor resolves every URL it reads out of Quora's payloads through the same `abs_url()` helper.

**Engagement fields** — `upvotes`, `comments_count`, `shares_count` on answers; `answer_count`, `follow_count` on questions; `follower_count`, `question_count`, `post_count`, `contributor_count` on profiles/topics/spaces — are coerced to plain integers even though Quora itself serializes many of them as strings (`"1,240"`) in its GraphQL payloads.

**Reach fields on author leads** — `follower_count`, `following_count`, `answer_count`, `question_count`, `total_views` — are the raw signals `lead_score` is computed from. Unlike the engagement fields above, these stay `null` rather than `0` when the author's profile page couldn't be read, so a genuinely inactive author and a failed fetch never look identical in the data.

**Computed fields** — `lead_score` on author leads is derived, not a Quora field: `min(40, log10(followers+1)*8) + min(35, log10(views+1)*6) + min(25, log10(answers+1)*8)`, rounded to one decimal, capped at 100. It rewards the presence of all three reach signals rather than one dominant metric — a highly-followed author with few visible answers scores lower than one strong in all three. It returns `null`, not `0`, when the profile carried no usable reach data at all.

**Bookkeeping fields** — `source_url`, `scrape_timestamp` on every row, plus `source_query` on rows that came from a keyword search (empty string for rows sourced from `directUrls`) and `matched_keyword` on author leads (the first keyword that surfaced that author, not every keyword that did).

#### Content-type quick reference

| `content_type` value | Comes from | Distinguishing fields |
| --- | --- | --- |
| `question` | Keyword search or a question URL in `directUrls` | `answer_count`, `follow_count`, `topics` |
| `answer` | Same question pages, one row per answer | `answer_text`, `upvotes`, `is_ai_answer`, `author_credentials` |
| `profile` | A profile URL pasted into `directUrls` | `bio`, `credentials`, `total_views` — a static snapshot, not a lead |
| `topic` | A topic URL pasted into `directUrls` | `description`, `follower_count`, `question_count` |
| `space` | A space (`/q/...`) URL pasted into `directUrls` | `post_count`, `contributor_count` |
| `author_lead` | The enrichment pass over every distinct answer author | `lead_score`, `answers_seen_in_run`, `extracted_links`, `is_lead: true` |

### How does Quora Search Scraper With Author Lead Enrichment compare to other Quora lead enrichment scrapers?

| Feature | This Actor | Generic alternative |
| --- | --- | --- |
| Output format | Typed JSON, six discriminated content types in one schema | Often HTML or a single flat content type |
| Author-to-lead pipeline | Built in — dedupes answer authors and enriches each into a lead row automatically | Usually requires chaining a second scraper or manual profile lookups |
| Entity coverage | Questions, answers, profiles, topics, spaces and author leads | Typically one or two entity types |
| Proxy/anti-bot handling | Automatic DIRECT → DATACENTER → RESIDENTIAL ladder, sticky once escalated | Varies; often requires the caller to configure a proxy manually |
| Schema stability | Reads GraphQL payloads by field name, not CSS selectors | Selector-based scrapers break on layout changes |

If you're building an AI agent or RAG pipeline, the output format row is the decision-maker — parsing HTML inside an agent loop is a reliability failure mode, not a feature. `constructive_wainscot/companyscope-mcp`, checked on the Apify Store 2026-07-25, is a general company-research MCP server that aggregates 12 public data sources (not Quora-specific), and `anchor/linkedin-profile-enrichment`, checked the same date, advertises "+100 000 profile successfully enriched" on its listing as a LinkedIn-specific enrichment tool — not measured here — neither targets Quora's question/answer content the way this Actor does.

### How many results can you scrape with Quora Search Scraper With Author Lead Enrichment?

`maxResults` accepts up to 50,000 and is a total across all `searchQueries` and `directUrls` combined, not a per-query or per-URL figure — the Actor tracks a shared running budget and stops issuing new content rows once it's spent. Author-lead rows from the enrichment pass are added on top of that budget, one per distinct answer author, so a `maxResults` of 200 with `scrapeAuthorProfiles` on can still produce more than 200 total dataset rows once leads are counted. Pagination for large result sets works by scrolling the rendered page and capturing each streamed GraphQL response until the requested count is reached or the page stops yielding new answers. No benchmark run time is published — actual throughput depends on how many proxy escalations a given run needs.

Billing follows row count directly: every row pushed to the dataset — whether it's a `question`, `answer`, `profile`, `topic`, `space` or `author_lead` — fires the same `row_result` pay-per-event charge, once per row, with no separate event name for the enrichment pass and no uncharged accounting or error rows mixed into the dataset. That means an `author_lead` row with every reach field left `null` (profile fetch failed) is billed the same as one with a full reach profile — there's no partial-credit or refund path for a failed enrichment, so a very large `maxResults` combined with `scrapeAuthorProfiles` on a niche keyword with few real answers is the scenario most likely to surprise a first-time user with row count.

### Integrate Quora Search Scraper With Author Lead Enrichment and automate your workflow

Quora Search Scraper With Author Lead Enrichment works with any language or tool that can send an HTTP request through the Apify API.

#### 🔗 REST API integration

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run = client.actor("<YOUR_USERNAME>/quora-search-scraper-with-author-lead-enrichment").call(run_input={
    "searchQueries": ["what is python used for"],
    "maxResults": 50,
    "scrapeAuthorProfiles": True,
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    if item.get("content_type") == "author_lead":
        print(item["name"], item["lead_score"], item["extracted_links"])
```

Works in Python, Node.js, Go, Ruby, cURL — any language that can make an HTTP request.

#### Automation platforms (n8n, Make, LangChain)

In **n8n**, use the Apify node (or an HTTP Request node against the Apify run endpoint with your token) with the same JSON input shown above, then filter the output items node on `content_type == "author_lead"` to route only enriched leads into a CRM step. In **Make**, use the Apify module to start a run and the "Get Dataset Items" action to pull results straight into a Google Sheets or Airtable module — schedule it weekly for ongoing lead discovery on a keyword set. In **LangChain** or any custom agent framework, wrap the `client.actor(...).call()` pattern above as a tool function; the returned JSON needs no parsing step before it's passed into a prompt or a retriever.

### Is it legal to scrape Quora and build author lead lists?

Scraping publicly accessible Quora content is generally permissible when no login is used and no access controls are bypassed, and this Actor returns only what an anonymous visitor already sees — no Quora login, cookie or session is ever used.

Author-lead rows do include personal identifiers (name, bio, follower reach, profile URL) drawn from public profile pages, so GDPR/CCPA-style personal-data considerations apply if you store or process leads on EU or California residents — the Actor itself never returns an email address, since Quora's public profile pages carry none. Quora's own Terms of Service govern automated access to the site, separately from any personal-data regime. Consult legal counsel before using scraped author data for commercial outreach at scale, particularly across jurisdictions with distinct consent requirements for unsolicited contact.

### ❓ Frequently asked questions

#### Does Quora Search Scraper With Author Lead Enrichment work without a Quora account?

Yes. No Quora login, cookie or account is used anywhere in the Actor — searches are discovered via DuckDuckGo/Bing, and content pages are read as an anonymous visitor would see them.

#### How often is the scraped data updated?

Every run performs a live fetch — the Actor opens a real browser session against Quora (or the discovery search engines) on each execution. There is no caching layer; results reflect what Quora was serving at run time.

#### What happens if a search returns zero questions or an author's profile can't be opened?

If a keyword search yields no discoverable question URLs after climbing the full proxy ladder and retrying on residential, that keyword contributes zero rows and the run continues with the next keyword or URL — it is logged, not treated as a fatal error. If an individual author's profile page can't be opened during the enrichment pass, the Actor still emits an `author_lead` row for that author (name and URL carried over from the answer that surfaced them) with `follower_count`, `total_views` and the other reach fields left `null` rather than fabricated — and that row is still charged, since billing is per row pushed, not per successfully enriched field.

#### What's the difference between a `profile` row and an `author_lead` row?

A `profile` row is a plain snapshot of a Quora profile URL you pasted directly into `directUrls` — it carries `bio`, `credentials` and reach counts, nothing more. An `author_lead` row only comes from the enrichment pass over the authors who wrote answers your search or URLs surfaced, and additionally carries `lead_score`, `answers_seen_in_run` (how many of the run's answers that author wrote), `extracted_links` (bio links pulled for outreach) and `matched_keyword`. If you paste the same person's profile URL into `directUrls` *and* their answer gets surfaced by a search in the same run, you'll get both a `profile` row and an `author_lead` row for them — they are not deduplicated against each other, only leads are deduplicated among themselves.

#### Can I scrape private or restricted Quora content?

No. Only publicly accessible questions, answers and profile pages are returned — content behind a Quora login wall (some newer questions require sign-in to view answers) is not accessible to this Actor, since it never authenticates.

#### Is there a free trial before I pay for results?

The Actor is billed per `row_result` event on the Apify platform's pay-per-event model — check the Actor's pricing tab on its Apify Store listing for the current per-event rate and any free-tier usage included with your Apify plan.

#### Does it work for AI agent workflows and LLM pipelines?

Yes, as a standard HTTP endpoint callable through the Apify API — it is not currently reachable through an MCP server. Any agent framework that can call `client.actor(...).call()` (LangChain, CrewAI, a custom tool definition, n8n) receives typed JSON rows directly, with no HTML or selector-based parsing step required before passing a row to an LLM.

#### How does it handle Quora's anti-bot system?

Quora sits behind Cloudflare. The Actor renders every page with a stealth-patched Chromium browser (via `playwright-stealth`), waits out "Just a moment" / "Attention Required" interstitials with retries, and escalates through a DIRECT → DATACENTER → RESIDENTIAL proxy ladder — climbing only when a block is detected, and sticking on the higher rung once escalated rather than reverting. Once on residential, it grants extra retries (three, by default) before giving up on a URL.

#### How does it compare to other Quora scrapers?

Most Actors on the Apify Store positioned near "lead enrichment," checked 2026-07-25, target company or LinkedIn data rather than Quora specifically — `fortunate_favorite/company-intelligence` analyzes a company domain into an AI-written business summary, and `constructive_wainscot/companyscope-mcp` aggregates 12 public company-data sources behind an MCP server. Neither returns Quora questions, answers or author-derived leads; this Actor's differentiator is turning Quora's own answer authors into a scored, deduplicated lead list without a second tool.

#### Does it return data in a format LLMs can use directly?

Yes. Every row is typed, normalized JSON with stable field names across runs. No HTML, no selectors, no parsing step. Pass a row directly into an LLM context window, index it into a vector store, or route it through an agent tool.

#### Can I use it without managing proxies?

Yes. Leave `proxyConfiguration` at its default (`{"useApifyProxy": true}`) and the Actor handles the DIRECT → DATACENTER → RESIDENTIAL escalation, retry backoff and sticky-session behavior itself. You never rotate an IP or manage a proxy account directly.

#### What happens when Quora changes its structure or blocks the scraper?

The scraper is maintained, and because it reads Quora's embedded GraphQL data by field name rather than CSS selectors, a visual redesign typically doesn't affect it — only a change to the underlying GraphQL schema would. Field names and types on your end do not change. No numeric turnaround time is promised.

### 💬 Your feedback

Found a bug, or a Quora field that should be in the output but isn't? Open an issue on the Actor's Issues tab on Apify — a field request backed by a sample question, profile or search keyword is the fastest to act on.

# Actor input Schema

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

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

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

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

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

Total number of CONTENT rows (answers/questions/profiles/topics/spaces) to collect across all keywords and URLs combined. Author-lead rows are added on top — one per distinct answer author. ✅ Example: 10.

## `scrapeAuthorProfiles` (type: `boolean`):

✅ On: for every distinct answer author found, open their public profile and emit an enriched author\_lead row — bio, credentials, follower/following/answer/question counts, total views, computed lead\_score and bio links. ⬜ Off: keep only the author name on each answer. Default: on.

## `authorFilter` (type: `string`):

Only keep answers and leads written by this author (Quora display name or profile slug) — track one expert across all your keywords. Matched client-side against author name / profile URL. Leave empty for all authors.

## `location` (type: `string`):

Bias keyword discovery toward a location (e.g. "London", "New York") by appending it to the search query. NOTE: this biases which questions are discovered — it does NOT filter authors by geography (Quora exposes no reliable author location). Leave empty for global search.

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

OFF by default. When on AND a key is supplied, each author lead also gets ai\_expertise and ai\_intent inferred from its public bio and credentials. On failure or without a key these fields stay null.

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

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

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

Provider API key for AI enrichment. Kept secret. Falls back to the provider env var if empty (ANTHROPIC\_API\_KEY / OPENAI\_API\_KEY / GEMINI\_API\_KEY / XAI\_API\_KEY / DEEPSEEK\_API\_KEY / PERPLEXITY\_API\_KEY / MISTRAL\_API\_KEY).

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

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

## Actor input object example

```json
{
  "searchQueries": [
    "python programming"
  ],
  "directUrls": [],
  "maxResults": 10,
  "scrapeAuthorProfiles": true,
  "authorFilter": "",
  "location": "",
  "aiEnhancement": false,
  "aiModel": "claude-haiku-4-5",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "searchQueries": [
        "python programming"
    ],
    "directUrls": [],
    "maxResults": 10,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("api-empire/quora-search-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "searchQueries": ["python programming"],
    "directUrls": [],
    "maxResults": 10,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

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

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

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

```

## CLI example

```bash
echo '{
  "searchQueries": [
    "python programming"
  ],
  "directUrls": [],
  "maxResults": 10,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call api-empire/quora-search-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

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