# Quora Scraper (`botflowtech/quora-scraper`) Actor

Quora Scraper

- **URL**: https://apify.com/botflowtech/quora-scraper.md
- **Developed by:** [BotFlowTech](https://apify.com/botflowtech) (community)
- **Categories:** Social media
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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 Pro — Questions, Answers, Profiles, Topics & Spaces

The most comprehensive and cost-efficient Quora data extraction tool on Apify. Extract structured data from the world's largest Q&A platform — no Quora account or login required.

**Pricing: from $5.00 / 1,000 results** — the most affordable Quora scraper on the marketplace.

---

### ⚡ Key Features

| Feature | Description |
|---------|-------------|
| **🔍 Keyword Search** | Enter any search term → get relevant questions + all their answers automatically |
| **🔗 Direct URL Scraping** | Provide question, profile, topic, or space URLs to target specific pages |
| **📝 Full Answer Extraction** | Complete answer text, not truncated — with author info, credentials, upvotes & engagement |
| **🤖 AI Answer Detection** | Automatically flags Quora AI-generated answers vs. human answers |
| **👤 Profile Scraping** | Extract user bios, credentials, follower counts, answer stats, and total views |
| **📊 Topic & Space Data** | Get topic descriptions, follower counts, and space contributor info |
| **🌐 Multi-Language** | Supports 10 languages: English, Spanish, French, German, Italian, Portuguese, Japanese, Hindi, Indonesian, Arabic |
| **⚡ Blazing Fast** | Blocks images, fonts & trackers — 3-5x faster than browser-based alternatives |
| **💰 Pay Per Result** | Only pay for actual results — no wasted compute costs |

---

### 🎯 Use Cases

#### Content Marketing & SEO
- **Content ideation**: Find trending questions in your niche to create blog posts, videos, and FAQs
- **Keyword research**: Discover long-tail keywords from real user questions
- **Competitor analysis**: Track what questions people ask about your competitors

#### Market Research & Product Development
- **Voice of customer**: Understand what real users think about products, tools, and services
- **Sentiment analysis**: Analyze opinions and recommendations across thousands of answers
- **Trend tracking**: Monitor emerging topics and shifting interests over time

#### Lead Generation & Sales
- **Expert discovery**: Find industry experts and thought leaders by their credentials and engagement
- **Profile harvesting**: Build targeted lists of professionals active in specific topics
- **Community mapping**: Identify active Quora Spaces related to your industry

#### Academic & Data Science
- **Research datasets**: Build Q&A datasets for NLP/ML training
- **Knowledge graphs**: Extract topic relationships and expert networks
- **AI benchmarking**: Compare human vs. AI-generated answers at scale

---

### 📥 Input Configuration

#### Basic Usage — Search by Keywords
```json
{
    "searchKeywords": ["machine learning", "startup funding"],
    "maxResultsPerQuery": 10,
    "maxAnswersPerQuestion": 20
}
````

#### Direct URL Scraping

```json
{
    "directUrls": [
        "https://www.quora.com/What-is-Python-used-for",
        "https://www.quora.com/profile/Elon-Musk-1",
        "https://www.quora.com/topic/Artificial-Intelligence"
    ],
    "contentTypes": ["questions", "answers", "profiles", "topics"]
}
```

#### Advanced — Filtered High-Quality Answers Only

```json
{
    "searchKeywords": ["best programming language 2026"],
    "maxResultsPerQuery": 25,
    "maxAnswersPerQuestion": 50,
    "filterAiAnswers": "exclude",
    "minUpvotes": 10,
    "sortAnswersBy": "upvotes",
    "includeHtmlContent": true
}
```

#### Input Parameters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `searchKeywords` | string\[] | — | Keywords to search on Quora |
| `directUrls` | string\[] | — | Direct Quora URLs (questions, profiles, topics, spaces) |
| `contentTypes` | string\[] | `["questions", "answers"]` | What to extract: questions, answers, profiles, topics, spaces |
| `maxResultsPerQuery` | integer | `10` | Max question pages per keyword (1-500) |
| `maxAnswersPerQuestion` | integer | `20` | Max answers per question (1-100) |
| `sortAnswersBy` | string | `"relevance"` | Sort order: relevance, recency, upvotes |
| `filterAiAnswers` | string | `"include"` | AI filter: include, exclude, only |
| `minUpvotes` | integer | `0` | Minimum upvotes threshold |
| `language` | string | `"en"` | Search language (10 supported) |
| `includeHtmlContent` | boolean | `false` | Include raw HTML alongside text |
| `maxConcurrency` | integer | `5` | Parallel pages (1-20) |
| `proxyConfiguration` | object | Residential | Proxy settings |

***

### 📤 Output Data

#### Question Results

```json
{
    "contentType": "question",
    "title": "What is the best programming language for beginners in 2026?",
    "url": "https://www.quora.com/What-is-the-best-programming-language-for-beginners-in-2026",
    "answerCount": 147,
    "followCount": 892,
    "viewCount": 0,
    "topics": ["Programming Languages", "Software Engineering", "Learn to Code"],
    "sourceQuery": "best programming language",
    "scrapeTimestamp": "2026-03-18T17:30:00.000Z"
}
```

#### Answer Results

```json
{
    "contentType": "answer",
    "questionTitle": "What is the best programming language for beginners in 2026?",
    "questionUrl": "https://www.quora.com/What-is-the-best-programming-language-for-beginners-in-2026",
    "answerText": "Python is widely regarded as the best language for beginners because...",
    "answerUrl": "https://www.quora.com/.../answer/John-Smith",
    "authorName": "John Smith",
    "authorUrl": "https://www.quora.com/profile/John-Smith",
    "authorCredentials": "Senior Software Engineer at Google",
    "upvotes": 234,
    "commentsCount": 12,
    "sharesCount": 5,
    "isAiAnswer": false,
    "answerDate": "2y",
    "sourceQuery": "best programming language",
    "scrapeTimestamp": "2026-03-18T17:30:00.000Z"
}
```

#### Profile Results

```json
{
    "contentType": "profile",
    "name": "Jane Doe",
    "url": "https://www.quora.com/profile/Jane-Doe",
    "bio": "Tech entrepreneur and angel investor...",
    "credentials": "CEO at TechStartup Inc.",
    "profileImageUrl": "https://...",
    "followerCount": 15200,
    "followingCount": 340,
    "answerCount": 892,
    "questionCount": 45,
    "totalViews": 12500000,
    "scrapeTimestamp": "2026-03-18T17:30:00.000Z"
}
```

#### Topic Results

```json
{
    "contentType": "topic",
    "name": "Artificial Intelligence",
    "url": "https://www.quora.com/topic/Artificial-Intelligence",
    "description": "Artificial intelligence (AI) is...",
    "followerCount": 3200000,
    "questionCount": 125000,
    "scrapeTimestamp": "2026-03-18T17:30:00.000Z"
}
```

#### Space Results

```json
{
    "contentType": "space",
    "name": "Data Science Central",
    "url": "https://www.quora.com/q/data-science-central",
    "description": "A community for data scientists...",
    "followerCount": 89000,
    "postCount": 2340,
    "contributorCount": 156,
    "scrapeTimestamp": "2026-03-18T17:30:00.000Z"
}
```

***

### ⚡ Performance & Optimization

This scraper is built for **speed and cost efficiency**:

- **Resource blocking**: Automatically blocks images, fonts, CSS, and tracking scripts — reducing bandwidth by 60-80%
- **Smart scrolling**: Only scrolls as much as needed to load the requested number of answers
- **Parallel processing**: Configurable concurrency (up to 20 parallel pages)
- **Retry logic**: Built-in 3-retry mechanism with exponential backoff for failed requests
- **Graceful charge limits**: Automatically stops when the user's spending limit is reached

#### Typical Performance

| Scenario | Time | Approx. Cost |
|----------|------|-------------|
| 1 keyword, 10 questions, 20 answers each | ~2 min | ~$1.00 |
| 5 keywords, 50 questions total | ~8 min | ~$5.00 |
| 10 direct question URLs | ~3 min | ~$2.00 |
| 100 profile URLs | ~15 min | ~$5.00 |

***

### 🔧 Integration & API

Use this scraper programmatically via the Apify API:

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")
run = client.actor("your-username/quora-scraper-pro").call(
    run_input={
        "searchKeywords": ["artificial intelligence"],
        "maxResultsPerQuery": 10,
        "maxAnswersPerQuestion": 20,
        "filterAiAnswers": "exclude",
    }
)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

#### JavaScript

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

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });
const run = await client.actor('your-username/quora-scraper-pro').call({
    searchKeywords: ['artificial intelligence'],
    maxResultsPerQuery: 10,
    maxAnswersPerQuestion: 20,
    filterAiAnswers: 'exclude',
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Webhooks & Integrations

- **Zapier**: Trigger workflows when new data is scraped
- **Google Sheets**: Auto-export results to spreadsheets
- **Slack**: Get notifications when scraping completes
- **n8n**: Build automated data pipelines

***

### ❓ FAQ

**Q: Does this require a Quora login?**
No. The scraper only extracts publicly visible data. No account or cookies needed.

**Q: Can Quora block this scraper?**
The scraper uses residential proxies by default, making it highly resistant to blocks. If you experience issues, try reducing concurrency.

**Q: What's the difference between "questions" and "answers" content types?**
"Questions" extracts the question metadata (title, topics, follow count). "Answers" extracts the actual answer content with author info and engagement metrics. You'll typically want both.

**Q: How does AI answer detection work?**
The scraper identifies Quora's AI-generated answers (Poe bot) by detecting AI badges, bot user names, and Quora AI markers in the page DOM.

**Q: Can I export to CSV/Excel?**
Yes! Apify datasets support export to JSON, CSV, Excel, XML, and RSS formats — available from the dataset page or via API.

***

### 📋 Changelog

#### v1.0.0 (March 2026)

- Initial release
- Keyword search + direct URL scraping
- Full question, answer, profile, topic, and space extraction
- AI answer detection
- Pay-per-event monetization
- Multi-language support (10 languages)
- Resource blocking for speed optimization

***

### 🛡️ Legal & Compliance

This Actor only extracts publicly available data from Quora. It does not access private profiles, paywalled content, or require any login credentials. Users are responsible for ensuring their use of the extracted data complies with applicable laws and Quora's Terms of Service.

***

**Built with ❤️ by [BotFlowTech](https://github.com/botflowtech) using [Crawlee](https://crawlee.dev/) + [Playwright](https://playwright.dev/)**

# Actor input Schema

## `searchKeywords` (type: `array`):

Keywords to search for on Quora. The scraper finds relevant questions for each keyword and extracts all data. Example: \['machine learning', 'startup funding']

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

Direct Quora URLs to scrape — supports question pages, user profiles, topic pages, and space pages. Example: https://www.quora.com/What-is-Python-used-for

## `contentTypes` (type: `array`):

Select which content types to extract. Leave empty for all types.

## `maxResultsPerQuery` (type: `integer`):

Maximum number of question pages to process per search keyword. Each question page yields 1 question + multiple answers.

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

Maximum number of answers to extract from each question page. Set lower for faster runs.

## `sortAnswersBy` (type: `string`):

How to sort answers on each question page before extraction.

## `filterAiAnswers` (type: `string`):

Filter AI-generated answers (Quora's AI bot answers).

## `minUpvotes` (type: `integer`):

Only extract answers with at least this many upvotes. Set to 0 for all answers.

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

Preferred language for Quora search results.

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

Include raw HTML of answers alongside plain text. Useful for preserving formatting, images, and links.

## `maxConcurrency` (type: `integer`):

Maximum number of pages to process in parallel. Higher = faster but uses more memory. Recommended: 5-10.

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

Proxy settings. Residential proxy is strongly recommended for Quora to avoid blocks.

## Actor input object example

```json
{
  "searchKeywords": [
    "artificial intelligence"
  ],
  "contentTypes": [
    "questions",
    "answers"
  ],
  "maxResultsPerQuery": 10,
  "maxAnswersPerQuestion": 20,
  "sortAnswersBy": "relevance",
  "filterAiAnswers": "include",
  "minUpvotes": 0,
  "language": "en",
  "includeHtmlContent": false,
  "maxConcurrency": 5,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "searchKeywords": [
        "artificial intelligence"
    ],
    "maxResultsPerQuery": 10,
    "maxAnswersPerQuestion": 20,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("botflowtech/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 = {
    "searchKeywords": ["artificial intelligence"],
    "maxResultsPerQuery": 10,
    "maxAnswersPerQuestion": 20,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("botflowtech/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 '{
  "searchKeywords": [
    "artificial intelligence"
  ],
  "maxResultsPerQuery": 10,
  "maxAnswersPerQuestion": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call botflowtech/quora-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Quora Scraper",
        "description": "Quora Scraper",
        "version": "0.0",
        "x-build-id": "5lZklVfme1g3GXFpp"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/botflowtech~quora-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-botflowtech-quora-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/botflowtech~quora-scraper/runs": {
            "post": {
                "operationId": "runs-sync-botflowtech-quora-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/botflowtech~quora-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-botflowtech-quora-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "searchKeywords": {
                        "title": "Search Keywords",
                        "type": "array",
                        "description": "Keywords to search for on Quora. The scraper finds relevant questions for each keyword and extracts all data. Example: ['machine learning', 'startup funding']",
                        "items": {
                            "type": "string"
                        }
                    },
                    "directUrls": {
                        "title": "Direct Quora URLs",
                        "type": "array",
                        "description": "Direct Quora URLs to scrape — supports question pages, user profiles, topic pages, and space pages. Example: https://www.quora.com/What-is-Python-used-for",
                        "items": {
                            "type": "string"
                        }
                    },
                    "contentTypes": {
                        "title": "Content Types to Extract",
                        "type": "array",
                        "description": "Select which content types to extract. Leave empty for all types.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "questions",
                                "answers",
                                "profiles",
                                "topics",
                                "spaces"
                            ],
                            "enumTitles": [
                                "Questions (title, URL, topics, follower count)",
                                "Answers (full text, author, upvotes, AI detection)",
                                "User Profiles (bio, credentials, followers, stats)",
                                "Topics (description, follower count, question count)",
                                "Spaces (description, followers, post count)"
                            ]
                        },
                        "default": [
                            "questions",
                            "answers"
                        ]
                    },
                    "maxResultsPerQuery": {
                        "title": "Max Results Per Search Query",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of question pages to process per search keyword. Each question page yields 1 question + multiple answers.",
                        "default": 10
                    },
                    "maxAnswersPerQuestion": {
                        "title": "Max Answers Per Question",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum number of answers to extract from each question page. Set lower for faster runs.",
                        "default": 20
                    },
                    "sortAnswersBy": {
                        "title": "Sort Answers By",
                        "enum": [
                            "relevance",
                            "recency",
                            "upvotes"
                        ],
                        "type": "string",
                        "description": "How to sort answers on each question page before extraction.",
                        "default": "relevance"
                    },
                    "filterAiAnswers": {
                        "title": "AI Answer Filter",
                        "enum": [
                            "include",
                            "exclude",
                            "only"
                        ],
                        "type": "string",
                        "description": "Filter AI-generated answers (Quora's AI bot answers).",
                        "default": "include"
                    },
                    "minUpvotes": {
                        "title": "Minimum Upvotes",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only extract answers with at least this many upvotes. Set to 0 for all answers.",
                        "default": 0
                    },
                    "language": {
                        "title": "Language",
                        "enum": [
                            "en",
                            "es",
                            "fr",
                            "de",
                            "it",
                            "pt",
                            "ja",
                            "hi",
                            "id",
                            "ar"
                        ],
                        "type": "string",
                        "description": "Preferred language for Quora search results.",
                        "default": "en"
                    },
                    "includeHtmlContent": {
                        "title": "Include HTML Content",
                        "type": "boolean",
                        "description": "Include raw HTML of answers alongside plain text. Useful for preserving formatting, images, and links.",
                        "default": false
                    },
                    "maxConcurrency": {
                        "title": "Max Concurrency",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Maximum number of pages to process in parallel. Higher = faster but uses more memory. Recommended: 5-10.",
                        "default": 5
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings. Residential proxy is strongly recommended for Quora to avoid blocks.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
