Quora Search Scraper By Content Type & Language Portal

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:

{
  "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.

{
  "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:

{
  "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

[
  {
    "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

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.