# Quora Dataset Builder (`crawlerbros/quora-dataset-builder`) Actor

Build bounded normalized Quora datasets from public URLs or native search seeds.

- **URL**: https://apify.com/crawlerbros/quora-dataset-builder.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:**
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

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 Dataset Builder

Build a clean, deduplicated Quora dataset from public questions, answers, profiles, Topics, Spaces, posts, comments, and search phrases. Choose separate rows, nested answers, flat joined records, or relationship-focused output for spreadsheets, databases, search indexes, and graph workflows.

### What this actor does

- Combines direct Quora URLs and discovery queries into one deduplicated dataset.
- Keeps one clear row per observed entity and joins parents only when Quora provides enough evidence.
- Returns explicit relationships such as question-to-answer, answer-to-author, comment-to-answer, and Space-to-content.
- Expands visible answers, comments, replies, profiles, Topics, Spaces, related content, media, and links with independent limits.
- Keeps less-common values under `details` while retaining every non-empty user-relevant field.

### Input

| Field | Type | Default | Description |
|---|---|---:|---|
| `directUrls` | list of URLs | one public question URL | Public Quora question, answer, profile, Topic, Space, or post pages. |
| `searchQueries` | list of text | none | Phrases used to discover public Quora pages. |
| `resultTypes` | list | question, answer, comment, profile, topic, space, post | Entity families to retain. |
| `outputFormat` | choice | `normalized` | `normalized`, `nested`, `flat`, or `edges`. |
| `outputFields` | list | all available | Optional field selection; identity and type fields remain usable. |
| `relationshipTypes` | list | all observed types | Limit relationship rows to selected relationship families. |
| `scrapeDepth` | choice | `detail` | `overview` for parents; `detail` for visible children and enrichment. |
| `maxResults` | number | `100` | Maximum rows/results across the run. |
| `maxResultsPerSource` | number | `0` | Maximum rows from each source; `0` uses the actor default. |
| `maxQuestions` | number | `25` | Maximum question parents. |
| `maxAnswersPerQuestion` | number | `50` | Maximum visible answers per question. |
| `maxCommentsPerAnswer` | number | `50` | Maximum visible comments per answer. |
| `maxCommentDepth` | number | `20` | Maximum visible nested-reply depth. |
| `maxRelatedContent` | number | `20` | Maximum related content items per source. |
| `maxRelationshipItemsPerCollection` | number | `500` | Maximum items in each relationship collection. |
| `maxGraphEdges` | number | `5000` | Maximum relationship edges. |
| `maxTopicPosts` | number | `50` | Maximum Topic posts. |
| `maxSpaceFeedItems` | number | `50` | Maximum Space feed items. |
| `includeQuestion` | true/false | `true` | Keep question rows. |
| `includeAuthor` | true/false | `true` | Keep public author/profile rows. |
| `includeAuthorSnapshot` | true/false | `false` | Keep a visible author summary. |
| `includeTopics` | true/false | `true` | Keep Topics attached to content. |
| `includeSpaces` | true/false | `false` | Keep visible Space context. |
| `includeComments` | true/false | `true` | Keep visible comments. |
| `includeReplyGraph` | true/false | `false` | Keep explicit visible reply relationships. |
| `includeRelatedContent` | true/false | `false` | Keep related content cards. |
| `includeMedia` | true/false | `true` | Keep visible image and video links. |
| `includeOutboundLinks` | true/false | `true` | Keep links visible in content. |
| `includeEntityGraph` | true/false | `false` | Build explicit relationships between entities. |
| `includeUnresolvedEdges` | true/false | `true` | Keep edges whose target is visible but not separately collected. |
| `includeProfileEdges` | true/false | `false` | Include profile relationship edges. |
| `includeQuestionFollowerEdges` | true/false | `false` | Include visible question-follower edges. |
| `includeAnswerUpvoterEdges` | true/false | `false` | Include visible answer-upvoter edges. |
| `includeRelationshipCounts` | true/false | `false` | Include visible relationship totals. |
| `includeSpaceRoleEdges` | true/false | `false` | Include visible Space role relationships. |
| `includeSpaceContentEdges` | true/false | `true` | Include visible Space-to-content relationships. |
| `includeSensitiveRelationshipData` | true/false | `false` | Include public relationship data that may be more sensitive. |
| `topCommentsOnly` | true/false | `false` | Keep only comments Quora marks as top comments. |
| `commentSortOrder` | choice | `observed` | Comment ordering exposed by Quora. |
| `language` | choice | `auto` | Language/locale for public page discovery. |
| `reachMode` | choice | `standard` | `standard`, `maximum`, or `direct` public access. |
| `cookies` | list of browser cookies | none | Optional cookies from your own authorized Quora session. Never enter a password. |
| `includeAccessIssues` | true/false | `false` | Add a labelled row when Quora does not make a source available. |

All limits are upper bounds on visible data. Quora’s own access and pagination boundaries can result in fewer rows. Empty optional fields are omitted.

### Output per record

The builder emits deduplicated rows with values Quora actually supplied. It never fabricates a parent, metric, date, or relationship.

#### Identity and text

- `recordType`, `id`, `url`, `title`, `text`, `collectedAt`, `accessState`, `activityType`, `details`
- `questionText`, `answerText`, `postText`, `commentText`, `profileBio`, `authorBio`, `topicDescription`, `spaceDescription`, `resultSnippet`
- `answers`, `comments` when `outputFormat` is `nested`

#### Questions, answers, comments, and authors

- `questionId`, `questionUrl`, `questionTitle`, `questionPublishedAt`, `questionUpdatedAt`, `questionLastAnsweredAt`, `isUnanswered`, `topics`, `relatedQuestions`
- `answerId`, `answerUrl`, `answerPostedAt`, `answerCreatedAt`, `answerRelativeAge`, `answerUpdatedAt`, `answerRank`, `answerVisibility`, `answerTextCompleteness`, `answerAccessOption`, `isAiAnswer`, `isTopAnswer`, `isTruncated`
- `authorName`, `authorUrl`, `authorId`, `authorHandle`, `authorCredentials`, `authorImageUrl`, `authorIsVerified`, `username`

#### Counts, engagement, and links

- `answerCount`, `followerCount`, `followingCount`, `questionCount`, `postCount`, `memberCount`, `contributorCount`, `viewCount`, `upvotes`, `commentsCount`, `sharesCount`, `commentReplyCount`, `reactionCount`, `totalAnswerViews`, `totalContentViews`, `answerToViewRatio`, `followToAnswerRatio`, `answersCollected`, `answersLimitReached`
- `images`, `videos`, `externalLinks`, `textCompleteness`, `searchRank`, `searchType`, `searchTitle`, `searchSnippet`, `isPromoted`
- `eventType`, `changeType`, `changes`

#### Relationship rows

- `fromUrl`, `toUrl`, and `relationshipType` identify an explicit relationship row.

Less-common observed facts are kept once under `details`. Run summaries, billing values, parser data, proxy data, cookie data, and repeated input values are not content rows.

### Examples

#### Separate rows for a question and its visible discussion

```json
{
  "directUrls": ["https://www.quora.com/What-is-Python-primarily-used-for"],
  "resultTypes": ["question", "answer", "comment", "profile"],
  "outputFormat": "normalized",
  "maxAnswersPerQuestion": 20,
  "maxCommentsPerAnswer": 10
}
```

#### Nested answers for an application export

```json
{
  "directUrls": ["https://www.quora.com/What-are-the-major-differences-between-NAFTA-and-TPP"],
  "resultTypes": ["question", "answer"],
  "outputFormat": "nested",
  "includeAuthor": true,
  "maxAnswersPerQuestion": 10
}
```

#### Graph-oriented relationships

```json
{
  "directUrls": ["https://www.quora.com/q/Pakistan"],
  "resultTypes": ["question", "answer", "profile", "relationship"],
  "outputFormat": "edges",
  "includeEntityGraph": true,
  "includeSpaceContentEdges": true,
  "maxGraphEdges": 500
}
```

#### Mixed discovery and direct sources

```json
{
  "searchQueries": ["community health workers in Kenya", "renewable energy cooperatives"],
  "directUrls": ["https://www.quora.com/topic/Urban-Planning"],
  "resultTypes": ["question", "answer", "topic", "profile"],
  "outputFormat": "flat",
  "maxResults": 100
}
```

#### Example output

```json
{
  "recordType": "answer",
  "id": "answer:https://www.quora.com/What-is-Python-primarily-used-for/answer/Manya-Agarwal-55",
  "url": "https://www.quora.com/What-is-Python-primarily-used-for/answer/Manya-Agarwal-55",
  "answerText": "Python makes it an ideal choice for learning programming.",
  "accessState": "public"
}
```

### Use cases

- **Data integration:** load stable, deduplicated Quora rows into a database.
- **Knowledge graphs:** connect questions, answers, authors, Topics, Spaces, and posts.
- **Search indexes:** index one row per visible entity with parent links.
- **Content research:** preserve answer and comment context without difficult nested blobs.
- **Relationship analysis:** export explicit, evidence-backed public edges.

### FAQ

#### What is the difference between the output formats?

`normalized` is easiest to query, `nested` keeps answers or comments with their parent, `flat` joins useful parent values into rows, and `edges` focuses on relationships.

#### Does deduplication remove useful data?

It removes repeated observations of the same entity while retaining stronger field values and source/coverage context.

#### Do I need cookies?

No. Cookies are optional and only add content visible to your own authorized session. They cannot make private, removed, or Quora+ pages public.

#### Why is a relationship missing?

The page did not provide enough explicit evidence to connect both endpoints. The builder does not guess relationships.

#### Can `maxGraphEdges` create relationships Quora did not show?

No. It only limits the number of observed relationships retained.

#### Why are there fewer rows than a visible Quora count?

The count may include hidden, deleted, gated, or otherwise unavailable records. Only content returned to the run is included.

#### How are blocked pages represented?

Enable `includeAccessIssues` to receive a labelled access row. A blocked page is not converted into a fake content row.

#### Is this affiliated with Quora?

No. This is a third-party actor using public Quora pages and public page data.

### Quora actor catalog

- [Quora Scraper](https://apify.com/crawlerbros/quora-scraper) — collect known public URLs, usernames, and mixed Quora content.
- [Quora Search Scraper](https://apify.com/crawlerbros/quora-search-scraper) — discover public Quora content from keywords and enrich matching pages.
- [Quora Dataset Builder](https://apify.com/crawlerbros/quora-dataset-builder) — build deduplicated content rows and explicit relationships.
- [Quora Monitor](https://apify.com/crawlerbros/quora-monitor-scraper) — compare watched pages, Spaces, and feeds across runs.

### Access notes

The builder attempts public Quora pages without cookies and keeps only observed values. Standard, maximum, and direct choices help with different public-access conditions, but no scraper can guarantee a future response for every Quora page.

# Actor input Schema

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

Overview is faster; detail follows visible answers, comments, and profile activity.

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

Terms used to discover public Quora records before joining them.

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

Choose the public record types to include.

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

Choose the dataset layout: normalized rows for databases, nested answers for parent-oriented JSON, flat rows for spreadsheets, or relationship rows for graph tools.

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

Optional export selection for API users. Leave empty to return every observed buyer-relevant field; fields absent from a page are omitted.

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

Keep a relationship when one endpoint is visible but the other cannot be verified.

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

Choose the public relationship groups to include. Only relationships explicitly visible on the page are returned.

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

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

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

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

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

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

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

Allow sensitive relationship details when you explicitly request follower, followed-by, want-answers, or voter relationships.

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

Emit privacy-preserving relationship\_collection rows with the real observed total (collection\_total\_text/collection\_total\_value) but no target identities. Requires relationship\_collection in resultTypes. Observed totals are not always a server-confirmed count.

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

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

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

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

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

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

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

Maximum question seeds or discovered question pages to process.

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

Maximum visible answers per question. Use a higher value, up to 50,000, when you want more answers; 0 skips answer rows in detailed mode.

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

Keep question rows in the joined dataset.

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

Keep deduplicated author rows supported by visible profile links.

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

Add a bounded public profile snapshot for each visible author profile link.

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

Keep Topic records and explicit Topic relationships.

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

Keep Space records and explicit Space relationships.

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

Collect visible comments and replies.

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

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

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

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

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

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

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

Order visible comments by Quora order, upvotes, reactions, replies, or newest date.

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

Enable bounded visible nested comment replies and explicit parent paths; this also enables comment rows. Hidden or unexpanded replies are not inferred.

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

Return media URLs visibly attached to records.

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

Return external links visibly attached to records.

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

Return explicit links between questions, answers, authors, Topics, Spaces, posts, and comments.

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

Maximum visible comments per answer. Use 0 to collect every comment Quora exposes before the run limit or access boundary.

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

Maximum visible nested reply depth when includeReplyGraph is enabled; reaching the bound is not complete history.

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

Maximum relationship records to return in addition to content rows.

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

Choose the Quora language version to request when available. This selects page language; it does not translate content.

## `cookies` (type: `array`):

Optional cookies from a Quora session you are authorized to use. Public collection is attempted without cookies first.

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

Public Quora URLs. The actor detects whether each is a question, answer, profile, topic, Space, or post.

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

Maximum joined records returned across all sources.

## `includeAccessIssues` (type: `boolean`):

Add one clearly labelled row for each page Quora did not make available. Leave off for a clean content-only dataset.

## `maxResultsPerSource` (type: `integer`):

Maximum records collected from each URL or search source before moving to the next source.

## `reachMode` (type: `string`):

Standard is the cost-conscious default. Maximum reach uses stronger routing when available. Direct connection is mainly useful when you already control the connection.

## Actor input object example

```json
{
  "scrapeDepth": "detail",
  "resultTypes": [
    "question",
    "answer",
    "comment",
    "profile",
    "topic",
    "space",
    "post"
  ],
  "outputFormat": "normalized",
  "outputFields": [],
  "includeUnresolvedEdges": true,
  "relationshipTypes": [],
  "includeProfileEdges": false,
  "includeQuestionFollowerEdges": false,
  "includeAnswerUpvoterEdges": false,
  "includeSensitiveRelationshipData": false,
  "includeRelationshipCounts": false,
  "includeSpaceRoleEdges": false,
  "includeSpaceContentEdges": true,
  "maxRelationshipItemsPerCollection": 500,
  "maxQuestions": 10,
  "maxAnswersPerQuestion": 50,
  "includeQuestion": true,
  "includeAuthor": true,
  "includeAuthorSnapshot": false,
  "includeTopics": true,
  "includeSpaces": false,
  "includeComments": true,
  "includeRelatedContent": false,
  "maxRelatedContent": 20,
  "topCommentsOnly": false,
  "commentSortOrder": "observed",
  "includeReplyGraph": false,
  "includeMedia": true,
  "includeOutboundLinks": true,
  "includeEntityGraph": false,
  "maxCommentsPerAnswer": 50,
  "maxCommentDepth": 20,
  "maxGraphEdges": 1000,
  "language": "auto",
  "directUrls": [
    "https://www.quora.com/What-is-Python-primarily-used-for"
  ],
  "maxResults": 25,
  "includeAccessIssues": false,
  "maxResultsPerSource": 0,
  "reachMode": "standard"
}
```

# Actor output Schema

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

Open all collected questions, answers, profiles, Topics, Spaces, posts, comments, search results, and relationships.

# 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 = {
    "outputFormat": "normalized",
    "includeUnresolvedEdges": true,
    "includeProfileEdges": false,
    "includeQuestionFollowerEdges": false,
    "includeAnswerUpvoterEdges": false,
    "includeSensitiveRelationshipData": false,
    "includeRelationshipCounts": false,
    "includeSpaceRoleEdges": false,
    "includeSpaceContentEdges": true,
    "maxQuestions": 10,
    "includeQuestion": true,
    "includeAuthor": true,
    "includeAuthorSnapshot": false,
    "includeTopics": true,
    "includeSpaces": false,
    "includeComments": true,
    "includeRelatedContent": false,
    "topCommentsOnly": false,
    "includeReplyGraph": false,
    "includeMedia": true,
    "includeOutboundLinks": true,
    "includeEntityGraph": false,
    "maxCommentDepth": 20,
    "maxGraphEdges": 1000,
    "directUrls": [
        "https://www.quora.com/What-is-Python-primarily-used-for"
    ],
    "maxResults": 25,
    "includeAccessIssues": false,
    "maxResultsPerSource": 0
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/quora-dataset-builder").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 = {
    "outputFormat": "normalized",
    "includeUnresolvedEdges": True,
    "includeProfileEdges": False,
    "includeQuestionFollowerEdges": False,
    "includeAnswerUpvoterEdges": False,
    "includeSensitiveRelationshipData": False,
    "includeRelationshipCounts": False,
    "includeSpaceRoleEdges": False,
    "includeSpaceContentEdges": True,
    "maxQuestions": 10,
    "includeQuestion": True,
    "includeAuthor": True,
    "includeAuthorSnapshot": False,
    "includeTopics": True,
    "includeSpaces": False,
    "includeComments": True,
    "includeRelatedContent": False,
    "topCommentsOnly": False,
    "includeReplyGraph": False,
    "includeMedia": True,
    "includeOutboundLinks": True,
    "includeEntityGraph": False,
    "maxCommentDepth": 20,
    "maxGraphEdges": 1000,
    "directUrls": ["https://www.quora.com/What-is-Python-primarily-used-for"],
    "maxResults": 25,
    "includeAccessIssues": False,
    "maxResultsPerSource": 0,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/quora-dataset-builder").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "outputFormat": "normalized",
  "includeUnresolvedEdges": true,
  "includeProfileEdges": false,
  "includeQuestionFollowerEdges": false,
  "includeAnswerUpvoterEdges": false,
  "includeSensitiveRelationshipData": false,
  "includeRelationshipCounts": false,
  "includeSpaceRoleEdges": false,
  "includeSpaceContentEdges": true,
  "maxQuestions": 10,
  "includeQuestion": true,
  "includeAuthor": true,
  "includeAuthorSnapshot": false,
  "includeTopics": true,
  "includeSpaces": false,
  "includeComments": true,
  "includeRelatedContent": false,
  "topCommentsOnly": false,
  "includeReplyGraph": false,
  "includeMedia": true,
  "includeOutboundLinks": true,
  "includeEntityGraph": false,
  "maxCommentDepth": 20,
  "maxGraphEdges": 1000,
  "directUrls": [
    "https://www.quora.com/What-is-Python-primarily-used-for"
  ],
  "maxResults": 25,
  "includeAccessIssues": false,
  "maxResultsPerSource": 0
}' |
apify call crawlerbros/quora-dataset-builder --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,crawlerbros/quora-dataset-builder"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

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