# Quora Scraper By Language Portal (`api-empire/quora-scraper`) Actor

🧠✨ Quora Scraper extracts Questions, Answers, Profiles, Topics & Spaces from Quora for market research, lead gen, and content insights. ⚡ Fast, structured data, SEO-friendly. Perfect for analysts & marketers.

- **URL**: https://apify.com/api-empire/quora-scraper.md
- **Developed by:** [API Empire](https://apify.com/api-empire) (community)
- **Categories:** Lead generation, SEO tools, Other
- **Stats:** 1 total users, 1 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 Scraper — Extract Questions, Answers and Profiles as JSON

Quora Scraper By Language Portal extracts questions, answers, user profiles, topics and spaces from any of 24 localized `{lang}.quora.com` sites — not just the English site. Every response returns typed, normalized JSON — no HTML, no selectors, no parsing — with each row tagged by the portal and ISO language code it came from, so a Spanish-language answer and an English-language answer about the same topic sit in the same dataset as directly comparable rows. No Quora account or login is required for any of it. After reading this page you'll know exactly which portal a keyword search or pasted URL routes to, every field the Actor writes per entity type, and how to point the run at a market other than the U.S. English site.

### What is Quora Scraper By Language Portal?

Quora Scraper By Language Portal is an Apify Actor that scrapes Quora's public question-and-answer platform across 24 separate localized communities — `www.quora.com` (English) plus 23 `{lang}.quora.com` sites including Spanish, French, German, Japanese, Hindi, Arabic and Polish. It returns five distinct entity types from a single input: questions, answers, user profiles, topics and Spaces. No Quora account, login or cookie is required — the Actor reads only what an anonymous visitor already sees.

It is reachable as a standard Apify Actor: start it from the Apify Console, schedule it, or call it through the Apify API from any language or agent framework that can make an HTTP request.

- Scrape **questions** — title, answer count, follower count, topic tags
- Scrape **answers** — full text, author, credentials, upvotes, comments, shares, AI-answer flag
- Scrape **profiles, topics and Spaces** — bio/description, follower counts, activity totals
- Route every search and fetch to one of 24 localized portals, tagging each row with `portal` + `language`
- Export as JSON, CSV or XLSX — no proxy management, no HTML parsing

### 🗂️ What data does Quora Scraper By Language Portal collect?

Every run returns rows for one or more of five content types, each carrying its own field set plus the shared `content_type`, `portal` and `language` columns.

| Data Type | Key Fields | JSON Field Names |
| --- | --- | --- |
| Questions | Title, answer/follower counts, topic tags | `title`, `answer_count`, `follow_count`, `topics` |
| Answers | Full text, author, engagement, AI-answer flag | `answer_text`, `author_name`, `upvotes`, `comments_count`, `is_ai_answer` |
| Profiles | Name, bio, credentials, follower/answer totals | `name`, `bio`, `credentials`, `follower_count`, `total_views` |
| Topics | Name, description, follower/question counts | `name`, `description`, `follower_count`, `question_count` |
| Spaces | Name, description, followers, posts, contributors | `name`, `description`, `follower_count`, `post_count`, `contributor_count` |

#### How the language portal routing actually works

`portal` is not a URL query parameter and not a locale header — it is **host-based subdomain routing**, resolved once per run in the Actor's own code (`src/main.py`) before any request goes out. Each of the 24 portal codes maps to a subdomain prefix (`PORTAL_HOSTS`, e.g. `ES` → `es`, `EN` → `www`); `set_portal()` builds the active host (`es.quora.com`) and base URL (`https://es.quora.com`) once at the start of the run, and every subsequent operation reads from that single active portal:

- **Search discovery** — keyword search doesn't call any Quora search endpoint at all; it queries DuckDuckGo with a `site:{portal-host} {keyword}` filter (`ddg_quora_urls()`), so results are pre-scoped to the chosen portal's domain before a single Quora page is fetched.
- **Direct URLs** — any pasted `www.quora.com` or bare `quora.com` URL is silently rewritten onto the active portal host (`route_url()`), preserving the path and query string. A URL that already points at a specific portal host, or at a genuine Space subdomain (e.g. `data-science.quora.com`), is left untouched — the router checks it against the full set of 24 portal subdomains before touching anything.
- **Relative links and the GraphQL endpoint** — any root-relative URL Quora returns in a payload (`/profile/...`), and the answer-pagination GraphQL endpoint itself, resolve onto the active portal's base URL, so pagination and author links stay on the same localized host as the page that produced them.
- **Output tagging** — every row is stamped with the two-letter `portal` code you selected (e.g. `"ES"`) and the matching ISO 639-1 `language` code (e.g. `"es"`) via a single tagging step applied to every pushed row.

One run scrapes one portal. To compare how a topic is discussed in Spanish vs. Japanese Quora, run the Actor twice with different `portal` values — the dataset schema is identical across portals, so the outputs merge cleanly.

#### Need more Quora data?

If your workflow is specifically about finding and qualifying people from Quora search results rather than covering all five entity types across markets, **Quora Search Scraper With Author Lead Enrichment** (same account) focuses on keyword search with author-level enrichment for lead discovery. Reach for this Actor instead when the priority is language-portal breadth and full entity coverage — questions, answers, profiles, topics and Spaces — rather than a single lead-generation workflow.

### Why not build this yourself?

Quora does not publish a general-purpose public API for searching or retrieving question, answer or profile data, so the realistic alternative to an Actor is a DIY scraper — and the maintenance burden is the actual cost, not the initial script.

Quora's page data is not in clean rendered HTML; it is embedded as escaped JSON inside `.push("...")` calls in the page script, and the answer list itself is fetched via a persisted GraphQL query that requires extracting a `formkey`, a base64 question-node ID, and a query hash pulled from a second, separately-fetched JS bundle — three moving pieces that have to be re-parsed from the page on every request. The GraphQL response itself comes back as a `multipart/mixed` document with a custom `qgqlmpb` boundary, not plain JSON. A generic HTTP client also gets served a Cloudflare "Just a moment" challenge shell that returns HTTP 200 with no real content, so naive scrapers silently collect empty rows instead of failing loudly.

This Actor handles all of it: it validates every fetched page against the actual data key it expects before accepting it (rejecting challenge shells that look like a 200 OK), harvests answers embedded server-side in the HTML first as a Cloudflare-resistant fallback, and only falls back to a real headless browser when a page is hard-blocked on every proxy tier.

Keyword discovery adds its own layer of reverse engineering, since it doesn't touch Quora's own search at all: it queries DuckDuckGo's HTML endpoint for a `vqd` session token, then paginates DuckDuckGo's `d.js` results endpoint with that token, parsing a `DDG.pageLayout.load('d', [...])` JavaScript call out of the response body rather than a documented JSON API. A block from DuckDuckGo itself (`anomalyDetectionBlock`) is handled as its own case, distinct from a Quora block.

The proxy side is the second cost. Every fetch starts with **no proxy at all** (direct, browser-impersonated TLS), and only escalates — first to a datacenter proxy, then to a residential proxy — the moment Quora rejects a request; once the ladder reaches residential it stays there for the rest of the run rather than dropping back down. Each target keeps one sticky residential exit IP across all of its own requests (a question page and every answer-pagination call for it, for example) so session-scoped values like the `formkey` stay valid, and up to six fresh residential IPs are tried in sequence with exponential backoff before a target is given up on. Running that ladder yourself means buying and rotating residential IPs, tracking which sessions are still "clean," and re-tuning all of it whenever Quora adjusts what a block looks like.

### Why do developers and teams scrape Quora?

#### For AI engineers and agent builders

Quora's answer corpus is real, long-form human writing organized by topic — useful as retrieval context or fine-tuning data that isn't scraped-and-cleaned boilerplate. An agent builder can pull `answer_text`, `author_credentials` and `topics` for a target subject, chunk on paragraph boundaries (the plain-text renderer already splits on Quora's own section breaks), and index the result into a vector store as grounded, attributed source material for a RAG pipeline — with `is_ai_answer` available to exclude Quora's own AI-generated answers from a "real human expertise" dataset.

#### For researchers and analysts

Quora's 24-portal spread makes it one of the few large Q\&A platforms where the same subject can be compared across language communities without switching sites. A researcher studying how a topic (health information, a product category, a political issue) is discussed differently in Spanish- vs. Hindi- vs. Arabic-speaking communities runs the same `searchQueries` against different `portal` values and diffs the resulting `answer_text` and `topics` fields — all public content, none of it requiring an account.

#### For marketers and content teams

`searchQueries` surfaces the actual questions a market is asking about a topic or product category, and `topics`/`follow_count` on the question rows show which threads have real audience attention. A content team mines high-follower questions in their category, checks which have thin or outdated top answers, and uses the gap to brief new content — repeated per portal to build a market-by-market content calendar instead of one written for English and translated after the fact.

#### For developers building data products

Because every row carries `portal` + `language` alongside a stable schema, the output slots directly into a localization or market-monitoring product without a mapping layer. A developer building a "what markets are saying about X" dashboard schedules this Actor across several portals, writes the merged dataset straight into a warehouse table, and gets a consistent join key (`content_type`, `portal`) for every run without touching parsing logic per language.

### How to scrape Quora (step by step)

1. Open **Quora Scraper By Language Portal** on the Apify Store and start a run (Apify Console or API — no separate signup beyond your Apify account).
2. Pick a **Language Portal** (`portal`) — leave it on the default `EN` to scrape `www.quora.com`, or choose one of the other 23 localized portals.
3. Provide `searchQueries` and/or `directUrls` — at least one is required in practice; a run with both empty logs a warning and exits with zero rows.
4. Set `maxResults` for how many answers/results you want per query or URL, and optionally turn on `includeHtmlContent` or `aiEnhancement`. Leave `proxyConfiguration` on its Apify Proxy default unless Quora is blocking you.
5. Click **Start**, then open the dataset — switch between the Overview, Questions, Answers, Profiles, Topics and Spaces views — and export as JSON, CSV or XLSX.

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

The Actor is maintained, and its output schema — field names and types — stays stable on your end even after a Quora update. Because it reads Quora's embedded GraphQL payloads by key rather than parsing rendered HTML by CSS class, a purely visual redesign typically doesn't affect it at all; a change to the GraphQL schema or query hash itself is the kind of change that needs an update on this side. No specific turnaround time is promised here.

### ⬇️ Input

All 12 parameters are optional — the input schema marks nothing as required, though the Actor does nothing useful if both `searchQueries` and `directUrls` are empty.

| Parameter | Required | Type | Description | Example Value |
| --- | --- | --- | --- | --- |
| `portal` | No | string | Localized Quora portal to search and scrape — 24 enum values (`EN`, `ES`, `FR`, `DE`, `IT`, `JP`, `ID`, `PT`, `HI`, `NL`, `DA`, `FI`, `NO`, `SV`, `MR`, `BN`, `TA`, `AR`, `HE`, `GU`, `KN`, `ML`, `TE`, `PL`). Each is a separate `{lang}.quora.com` site. Default `"EN"` (`www.quora.com`). | `"ES"` |
| `searchQueries` | No | array (string list) | Keywords to search on the selected portal. Each is resolved to relevant Quora URLs (`site:{portal}.quora.com …`) and scraped automatically. Leave empty to only use `directUrls`. No default. | `["programación python"]` |
| `directUrls` | No | array (string list) | Quora URLs to scrape in bulk — question, `/profile/...`, `/topic/...` or `/q/...` (Space) pages. Plain `www.quora.com` URLs are auto-routed to the chosen portal host. No default. | `["https://es.quora.com/Para-qué-sirve-Python"]` |
| `maxResults` | No | integer | Max results per search keyword, and max answers scraped per question URL. Minimum `1`, maximum `50000`. Default `50`. | `10` |
| `includeHtmlContent` | No | boolean | On: adds a `contentHtml` field to each item (rendered HTML — paragraphs, links, images) alongside the plain text. Off: clean text only. Default `false`. | `true` |
| `aiEnhancement` | No | boolean | On: detects each item's language and translates its text/title to English, adding `aiLanguage` + `aiTranslatedText` + `aiTranslatedTitle`. Best-effort — fields are `null` on any AI failure or missing key. Off (default): no AI call, no AI cost. Default `false`. | `false` |
| `aiModel` | No | string | AI model/provider for translation. Provider is auto-detected from the name prefix. 13 enum values: `claude-haiku-4-5`, `claude-sonnet-5`, `claude-opus-4-8` (Anthropic); `gpt-4o-mini`, `gpt-4o`, `gpt-4.1-mini` (OpenAI); `gemini-2.0-flash-lite`, `gemini-2.0-flash`, `gemini-2.5-flash` (Google); `grok-3-mini` (xAI); `deepseek-chat` (DeepSeek); `sonar` (Perplexity); `mistral-small-latest` (Mistral). Default `"claude-haiku-4-5"`. Only used when `aiEnhancement` is on. | `"claude-haiku-4-5"` |
| `aiApiKey` | No | string (secret, masked in the UI) | API key for the selected AI provider. If blank, the matching environment variable on the run is used instead: `ANTHROPIC_API_KEY`, `OPENAI_API_KEY`, `GEMINI_API_KEY`, `XAI_API_KEY`, `DEEPSEEK_API_KEY`, `PERPLEXITY_API_KEY` or `MISTRAL_API_KEY`. Only used when `aiEnhancement` is on. No default. | — |
| `requestDelay` | No | number | Polite delay in seconds before each request. Minimum `0`, maximum `30`. Default `0.5`. | `0.5` |
| `concurrency` | No | integer | Maximum pages fetched in parallel. Minimum `1`, maximum `20`. Default `6`. | `6` |
| `useBrowserFallback` | No | boolean | Render hard-blocked pages in a real headless browser as a last resort, after the proxy ladder is exhausted. Default `true`. | `true` |
| `proxyConfiguration` | No | object (proxy editor) | Apify Proxy settings. The Actor starts **direct** (no proxy) regardless of this setting and only escalates to datacenter, then residential, if Quora blocks a request — see below for what happens if you disable it entirely. Prefilled `{"useApifyProxy": true}`. | `{"useApifyProxy": true}` |

#### Example input

```json
{
  "portal": "ES",
  "searchQueries": ["programación python"],
  "directUrls": ["https://es.quora.com/Para-qué-sirve-Python"],
  "maxResults": 10,
  "includeHtmlContent": true,
  "aiEnhancement": false,
  "aiModel": "claude-haiku-4-5",
  "aiApiKey": "",
  "requestDelay": 0.5,
  "concurrency": 6,
  "useBrowserFallback": true,
  "proxyConfiguration": { "useApifyProxy": true }
}
```

**Common pitfall:** leaving both `searchQueries` and `directUrls` empty. Nothing in the schema forces you to fill either one, but the run exits immediately with a warning and zero dataset rows if both are blank — there is no "scrape everything" fallback.

### ⬆️ Output

Each row carries a `content_type` discriminator (`"question"`, `"answer"`, `"profile"`, `"topic"` or `"space"`) plus the shared `portal` and `language` provenance columns stamped onto every row. With `includeHtmlContent` on, a `contentHtml` field is added to every row type. With `aiEnhancement` on and a resolved API key, `aiLanguage`, `aiTranslatedText` and (where the item has a distinct title) `aiTranslatedTitle` are added — otherwise these three fields are simply absent, not `null` placeholders. Export as JSON, CSV or XLSX, or read the dataset through the Apify API.

#### Scraped question

```json
{
  "content_type": "question",
  "title": "¿Para qué sirve Python?",
  "url": "https://es.quora.com/Para-qué-sirve-Python",
  "answer_count": 14,
  "follow_count": 212,
  "topics": ["Python (lenguaje de programación)", "Programación"],
  "source_url": "https://es.quora.com/Para-qué-sirve-Python",
  "source_query": "programación python",
  "scrape_timestamp": "2026-07-15T07:46:04.556861+00:00",
  "contentHtml": "<p>¿Para qué sirve Python?</p>",
  "portal": "ES",
  "language": "es"
}
```

#### Scraped answer

```json
{
  "content_type": "answer",
  "title": "¿Para qué sirve Python?",
  "url": "https://es.quora.com/Para-qué-sirve-Python/answer/Juan-Pérez-123",
  "answer_text": "Python es un lenguaje de programación de alto nivel usado en desarrollo web, ciencia de datos y automatización...",
  "answer_url": "https://es.quora.com/Para-qué-sirve-Python/answer/Juan-Pérez-123",
  "author_name": "Juan Pérez",
  "author_url": "https://es.quora.com/profile/Juan-Pérez-123",
  "author_credentials": "Ingeniero de Software",
  "upvotes": 42,
  "comments_count": 3,
  "shares_count": 1,
  "answer_timestamp": "2y",
  "is_ai_answer": false,
  "question_title": "¿Para qué sirve Python?",
  "question_url": "https://es.quora.com/Para-qué-sirve-Python",
  "source_url": "https://es.quora.com/Para-qué-sirve-Python",
  "source_query": "programación python",
  "scrape_timestamp": "2026-07-15T07:46:12.118203+00:00",
  "contentHtml": "<p>Python es un lenguaje de programación de alto nivel usado en desarrollo web, ciencia de datos y automatización...</p>",
  "portal": "ES",
  "language": "es",
  "aiLanguage": "es",
  "aiTranslatedText": "Python is a high-level programming language used in web development, data science and automation...",
  "aiTranslatedTitle": "What is Python used for?"
}
```

#### Scraped profile

```json
{
  "content_type": "profile",
  "title": "Guido van Rossum",
  "name": "Guido van Rossum",
  "url": "https://es.quora.com/profile/Guido-van-Rossum-1",
  "bio": "Creador de Python.",
  "credentials": "Creador del lenguaje de programación Python",
  "profile_image_url": "https://qph.cf2.quoracdn.net/main-thumb-guido.jpeg",
  "follower_count": 31500,
  "following_count": 12,
  "answer_count": 87,
  "question_count": 4,
  "total_views": 12800000,
  "source_url": "https://es.quora.com/profile/Guido-van-Rossum-1",
  "scrape_timestamp": "2026-07-15T07:47:01.884012+00:00",
  "portal": "ES",
  "language": "es"
}
```

#### Scraped topic

```json
{
  "content_type": "topic",
  "title": "Python (lenguaje de programación)",
  "name": "Python (lenguaje de programación)",
  "url": "https://es.quora.com/topic/Python-lenguaje-de-programación-1",
  "description": "Python es un lenguaje de programación interpretado de alto nivel.",
  "follower_count": 48200,
  "question_count": 630,
  "source_url": "https://es.quora.com/topic/Python-lenguaje-de-programación-1",
  "scrape_timestamp": "2026-07-15T07:47:22.301449+00:00",
  "portal": "ES",
  "language": "es"
}
```

#### Scraped Space

```json
{
  "content_type": "space",
  "title": "Ciencia de Datos",
  "name": "Ciencia de Datos",
  "url": "https://es.quora.com/q/ciencia-de-datos",
  "description": "Un espacio para discutir análisis de datos, machine learning y estadística.",
  "follower_count": 9100,
  "post_count": 340,
  "contributor_count": 18,
  "source_url": "https://es.quora.com/q/ciencia-de-datos",
  "scrape_timestamp": "2026-07-15T07:47:40.552217+00:00",
  "portal": "ES",
  "language": "es"
}
```

### How does Quora Scraper By Language Portal compare to other Quora scrapers?

| Feature | Quora Scraper By Language Portal | Generic alternative |
| --- | --- | --- |
| Localized language portals | 24 `{lang}.quora.com` portals, automatic subdomain routing for both search and direct URLs | Not documented on the listings of `fatihtahta/quora-scraper` or `crawlerbros/quora-scraper`, checked on the Apify Store 2026-07-25 — both operate against `www.quora.com` only in their published examples |
| Raw HTML passthrough | Opt-in `contentHtml` field (rendered markup) alongside plain text, per row | Not documented on either competitor listing, checked 2026-07-25 |
| AI translation | Opt-in, 7 providers auto-detected from the model name, best-effort → `null`/absent fields, uses your own key | Not documented on either competitor listing, checked 2026-07-25 |
| Entity coverage | 5 types: questions, answers, profiles, topics, Spaces | `crawlerbros/quora-scraper` documents the same 5 types; `fatihtahta/quora-scraper` documents 6, adding "posts", per its own listing checked 2026-07-25 |
| Documented pricing model | Pay-per-event (see the Actor's Pricing tab on the Apify Store for current rates) | `fatihtahta/quora-scraper`'s README title states "$5 / 1K"; `crawlerbros/quora-scraper`'s README states "$5 per 1,000 results" — both as documented on their own listings, checked 2026-07-25 |

If you're building an AI agent or RAG pipeline, the entity-coverage and language-portal rows are the decision-makers — parsing HTML or re-running a query per market inside an agent loop is a reliability failure mode, not a feature.

### How many results can you scrape with Quora Scraper By Language Portal?

`maxResults` caps at 50,000 and applies per search keyword and per direct question URL (as the max number of answers pulled from that one question) — it is a schema-enforced ceiling in this Actor, not a limit Quora itself publishes. There is no separate total-run cap: with multiple `searchQueries` or `directUrls`, results from each are collected independently and all land in the same dataset, so the practical total is the sum across everything you supply.

For keyword search specifically, the real-world ceiling is often lower than `maxResults`: discovery goes through DuckDuckGo (`site:{portal} {keyword}`) rather than Quora's own search, and DuckDuckGo simply may not index enough matching pages for a narrow or unusual query — the Actor pages through DuckDuckGo results until it hits your target or DuckDuckGo stops returning new URLs, whichever comes first. Direct URLs (`directUrls`) don't have this dependency: they're scraped exactly as supplied, so pasting known question/profile/topic/Space URLs is the more predictable path for a fixed target list.

Answer pagination on a question page works the same way regardless of how the URL was found: the Actor first harvests any answers already embedded server-side in the page HTML (fast, and resistant to a Cloudflare challenge on the paginated GraphQL endpoint), then — if `maxResults` isn't satisfied yet — walks the same persisted GraphQL query Quora's own frontend uses, in batches of up to 20 answers per request, until it reaches your target, runs out of pages, or Quora reports no next page. `concurrency` (default 6, max 20) controls how many *targets* — questions, profiles, topics, Spaces — are fetched in parallel, not how many answer-pagination requests run in parallel within a single question. No benchmark timing is given here, since none has been measured for this Actor.

### Integrate Quora Scraper By Language Portal and automate your workflow

Quora Scraper By Language Portal works with any language or tool that can send an HTTP request — it runs as a standard Apify Actor with no separate API surface of its own.

#### REST API integration

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run = client.actor("<YOUR_USERNAME>/quora-scraper-by-language-portal").call(run_input={
    "portal": "ES",
    "searchQueries": ["programación python"],
    "maxResults": 10,
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["content_type"], item["portal"], item.get("title") or item.get("name"))
```

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

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

In **n8n**, use the built-in Apify node (or an HTTP Request node against the Apify run endpoint) with the JSON input shown above — this is how you'd schedule a weekly multi-portal sweep without writing a scheduler yourself. In **Make**, the Apify module maps run input the same way and can feed the resulting dataset items straight into a Google Sheets or Airtable step per row. For a **LangChain** or similar agent tool, wrap the `apify_client` call above as a tool function — the Actor's response is already typed JSON, so no output parser is needed before handing results to the agent.

### Is it legal to scrape Quora?

Scraping publicly accessible web pages is broadly permitted; this Actor collects only what an anonymous, logged-out visitor already sees on Quora's public question, answer, profile, topic and Space pages — nothing behind a login wall.

Some of what it returns is personal data under GDPR/CCPA-style regimes — specifically `author_name`, `author_url`, `author_credentials` on answer rows, and `name`, `bio`, `credentials`, `profile_image_url` on profile rows, since these identify or describe real individuals. Question, topic and Space content (`title`, `description`, engagement counters) is user-generated platform content rather than personal data in the same sense, but where it includes attributable author text, the same personal-data considerations apply. You are responsible for having a lawful basis to store and process any personal data you collect, for honoring deletion or access requests where applicable, and for complying with Quora's own Terms of Service on top of that. Nothing gated behind a login — a private answer, a restricted Space, an authenticated-only view — is accessible to this Actor in the first place, since it never authenticates. Consult legal counsel for commercial use cases involving bulk personal data, especially before storing profile-level fields at scale across multiple portals.

### ❓ Frequently asked questions

#### Does Quora Scraper By Language Portal work without a Quora account?

Yes. No login, cookie or session is used anywhere in the Actor — it fetches public pages with a browser-impersonating HTTP client (and, as a last resort, a real headless browser), and reads only what's visible to an anonymous visitor.

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

Every run performs a live fetch — the Actor makes fresh HTTP requests to Quora (or DuckDuckGo, for keyword discovery) each time it runs. Nothing is cached between runs; re-running the same input re-scrapes current data.

#### What happens if a question, profile, topic or Space has no data or has been removed?

The Actor validates each fetched page for real content (not just an HTTP 200) before accepting it. If a target URL doesn't resolve to actual question/profile/topic/Space data — removed, mistyped, or not that content type — it's skipped with a warning logged and no row written for it; the run continues with the remaining URLs rather than failing outright or writing a placeholder row.

#### Can I scrape private or login-gated Quora content?

No. The Actor never authenticates, so anything Quora gates behind a login — private answers, restricted spaces, content requiring an account to view — is simply not reachable. Only what's visible to a logged-out visitor is returned.

#### What determines pricing for a run?

This Actor uses Apify's pay-per-event pricing model. For current per-event rates, check the Pricing tab on the Actor's Apify Store listing before running at volume — this README doesn't restate a number that could drift out of date.

#### Does Quora Scraper By Language Portal work for AI agent workflows and LLM pipelines?

Yes. It's callable as a standard HTTP endpoint through the Apify API, so any agent framework that can make a request — LangChain, CrewAI, a custom tool definition, n8n — can invoke it and get back typed JSON with no parsing step before passing it to an LLM.

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

Requests start direct (no proxy) with a Chrome-impersonating TLS/HTTP client (`curl_cffi`, impersonating Chrome 131). If Quora blocks a request, the Actor escalates to a datacenter proxy, then to a residential proxy — sticking with residential for the rest of the run once it's reached — retrying with fresh sticky exit IPs along the way (up to six residential attempts, with exponential backoff between them). A response is only accepted once it's checked for the actual data it should contain, not just a 200 status code, so a Cloudflare "Just a moment" challenge page that returns HTTP 200 is caught and retried rather than parsed into an empty row. If a page is still hard-blocked after the full proxy ladder, `useBrowserFallback` (on by default) renders it in a real headless Chromium browser as a last resort, itself rotating proxies across up to three attempts. Every escalation step is logged.

#### How does Quora Scraper By Language Portal compare to other Quora scrapers?

Checked on the Apify Store 2026-07-25, `fatihtahta/quora-scraper` and `crawlerbros/quora-scraper` both document keyword search and direct-URL scraping across similar entity sets, but neither documents multi-portal language targeting, raw HTML passthrough, or AI translation — the three capabilities this Actor adds on top of the same base entity coverage.

#### 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 cleanup pass. Pass a row straight 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, by default. `proxyConfiguration` is prefilled with Apify Proxy enabled, and the Actor handles the entire direct → datacenter → residential escalation itself. If you explicitly turn `useApifyProxy` off, the escalation ladder is fully disabled — the run stays direct-only for its entire duration, so if Quora blocks a direct request there's no automatic proxy fallback (the headless-browser fallback, if enabled, still runs without a proxy).

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

The scraper is maintained, and its output schema — field names and types — doesn't change on your end when Quora ships an update. No specific turnaround time is promised.

### 💬 Your feedback

Found a bug, or need a field that Quora exposes but this Actor doesn't return? Open an issue on the Actor's Issues tab in Apify Console — it helps keep the Actor accurate and is the fastest way to get a fix scheduled.

# Actor input Schema

## `portal` (type: `string`):

Which localized Quora portal to search and scrape. Each is a separate site ({lang}.quora.com) with its own questions and community. Example: ES scrapes es.quora.com and searches site:es.quora.com. Default is EN (www.quora.com).

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

Keywords to search on the selected portal. Each keyword is resolved to relevant Quora URLs (site:{portal}.quora.com) and scraped automatically. Leave empty to only use direct URLs.

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

Paste Quora URLs to scrape in bulk — questions, profiles (/profile/...), topics (/topic/...) or spaces (/q/...). Plain www.quora.com URLs are automatically routed to the chosen portal host. Example: https://es.quora.com/Para-qué-se-usa-Python

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

Max results per search keyword, and max answers scraped per question URL. Example: 10. Default is 50.

## `includeHtmlContent` (type: `boolean`):

✅ On: add a contentHtml field to each item — rendered HTML markup (paragraphs, links, images) alongside the plain text the scraper already emits, for downstream parsing. ⬜ Off: clean text only. Default is off.

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

✅ On: detect each item's language and translate its text/title to English, adding aiLanguage + aiTranslatedText + aiTranslatedTitle. Best-effort — fields are null if the AI call fails or no key is set. ⬜ Off (default): no AI, no AI cost.

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

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

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

API key for the selected provider. If blank, the matching environment variable is used: ANTHROPIC\_API\_KEY / OPENAI\_API\_KEY / GEMINI\_API\_KEY / XAI\_API\_KEY / DEEPSEEK\_API\_KEY / PERPLEXITY\_API\_KEY / MISTRAL\_API\_KEY. Only used when AI Enrichment is on.

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

Polite delay (seconds) before each request. Example: 0.5. Default is 0.5.

## `concurrency` (type: `integer`):

Maximum number of pages fetched in parallel. Example: 6. Default is 6.

## `useBrowserFallback` (type: `boolean`):

Render hard-blocked pages in a real headless browser as a last resort. Default is on.

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

Proxy settings. The scraper starts DIRECT (no proxy) and only escalates to datacenter, then residential, if Quora blocks the request — sticking with residential afterwards.

## Actor input object example

```json
{
  "portal": "EN",
  "searchQueries": [
    "programación python"
  ],
  "directUrls": [
    "https://es.quora.com/Para-qué-sirve-Python"
  ],
  "maxResults": 10,
  "includeHtmlContent": false,
  "aiEnhancement": false,
  "aiModel": "claude-haiku-4-5",
  "requestDelay": 0.5,
  "concurrency": 6,
  "useBrowserFallback": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# 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": [
        "programación python"
    ],
    "directUrls": [
        "https://es.quora.com/Para-qué-sirve-Python"
    ],
    "maxResults": 10,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("api-empire/quora-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": ["programación python"],
    "directUrls": ["https://es.quora.com/Para-qué-sirve-Python"],
    "maxResults": 10,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("api-empire/quora-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": [
    "programación python"
  ],
  "directUrls": [
    "https://es.quora.com/Para-qué-sirve-Python"
  ],
  "maxResults": 10,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call api-empire/quora-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/eRGjnLg8wVF1dL5W6/builds/h0Mu5W1jjd4XSyibQ/openapi.json