# Quora Scraper | No Cookies | $1 / 1K (`scrapers-hub/quora-scraper-no-cookies`) Actor

Quora scraper to extract publicly available questions, answers, topics, author profiles, engagement metrics, and other Quora data—no cookies required 💬📊 Perfect for market research, content analysis, SEO research, trend discovery, and AI datasets.

- **URL**: https://apify.com/scrapers-hub/quora-scraper-no-cookies.md
- **Developed by:** [Scrapers Hub](https://apify.com/scrapers-hub) (community)
- **Categories:** AI, SEO tools, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.99 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## What's an Apify Actor?

Actors are 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 — Fast, No-Browser Data Extraction for Questions, Answers, Topics & Spaces

The **Quora Scraper** is a lightweight, self-contained tool that pulls structured public data from Quora without launching a slow headless browser. Built on pure **HTTP requests + Regex + CSS selectors**, this Quora Scraper turns any Quora URL — a search results page, a Space, a Topic, or a single Question — into clean, normalized **JSON** records you can load straight into a database, spreadsheet, or analytics pipeline. 📊

If you have ever needed reliable Quora data for **market research**, **content ideas**, **SEO keyword discovery**, **lead generation**, or **sentiment analysis**, the Quora Scraper is designed to do exactly that — quickly, repeatably, and at scale. Below you will find everything you need to understand, configure, and run the Quora Scraper from start to finish. 👇

---

#### ✨ Why Choose This Quora Scraper

Most scraping tools rely on a full browser to render JavaScript, which makes them heavy, slow, and resource-hungry. The Quora Scraper takes a smarter route. It reaches Quora's pages directly, recovers the JSON that Quora embeds inside `<script>` tags, and reconstructs the same data the website itself uses to render content. That means **lower memory usage**, **faster runs**, and **fewer moving parts**. ⚡

##### 🔑 Key Highlights

- 🧠 **No headless browser required** — runs on plain HTTP, so it is fast and cheap.
- 🛡️ **Multi-backend fetching** — automatically rotates through browser-grade TLS impersonation, a challenge-solving HTTP client, and a standard request session to get past protection layers.
- 🔁 **Smart retry & fallback chain** — soft errors (rate limits, timeouts) are retried; hard blocks move straight to the next backend.
- 🧩 **Four record types** — `topic`, `space`, `question`, and `answer`, all normalized into one consistent schema.
- 🌐 **Optional browser rendering** — for JavaScript-heavy search pages, an optional render mode can be switched on when you need it.
- 📦 **Single-file design** — the entire Quora Scraper lives in one Python file with graceful dependency fallbacks, so it always imports even if an optional library is missing.

The result is a dependable Quora Scraper that behaves well under real-world conditions and degrades gracefully instead of crashing.

---

#### 🧮 Section 3 — Input & Output

This is the most important section for anyone configuring the Quora Scraper, so read it carefully. Everything the Quora Scraper does is driven by a simple input object, and everything it returns follows a predictable output schema. 🎯

##### 📥 Input

The Quora Scraper accepts a single JSON-style configuration object. You can edit it directly inside the script or supply it as a separate file. Here is the full shape:

```json
{
  "maxItemsPerQuery": 30,
  "startUrls": [
    "https://www.quora.com/search?q=pool",
    "https://humanity.quora.com/",
    "https://www.quora.com/Is-AI-an-existential-threat-to-humanity"
  ],
  "searchType": "Question",
  "timeFilter": "All Time",
  "cookies": "",
  "proxy": "",
  "useBrowser": false,
  "browserHeadless": false,
  "browserWaitMs": 12000,
  "chromeUserDataDir": ""
}
````

**Input fields explained:**

| Field | Type | What it does |
|---|---|---|
| `maxItemsPerQuery` | number | 🔢 Maximum records to collect per start URL. |
| `startUrls` | list | 🔗 Any mix of search, Space, Topic, or Question URLs. |
| `searchType` | string | 🏷️ One of `Question`, `Answer`, `Post`, `Profile`, `Topic`, `Space`, or `All`. |
| `timeFilter` | string | 🕒 `All Time`, `Hour`, `Day`, `Week`, `Month`, or `Year`. |
| `cookies` | string | 🍪 Optional logged-in session cookies for gated search results. |
| `proxy` | string | 🌍 Optional proxy URL (a residential proxy is strongly recommended). |
| `useBrowser` | boolean | 🖥️ Turn on optional rendering for JavaScript search pages. |
| `browserHeadless` | boolean | 👻 Run the optional renderer with or without a visible window. |
| `browserWaitMs` | number | ⏳ How long to wait for rendered results. |
| `chromeUserDataDir` | string | 👤 Reuse an existing browser profile so the Quora Scraper inherits your login. |

> 💡 **Tip:** The Quora Scraper works with **zero configuration** for direct Topic, Space, and Question URLs. Search pages are gated by Quora, so they need cookies or rendering — more on that further down.

##### 📤 Output

The Quora Scraper emits a **list of normalized records**. Every record carries a `record_type`, a `source_context` describing where it came from, a `status` block, and a type-specific payload. Here is a representative example of a `question` record:

```json
{
  "record_type": "question",
  "source_context": {
    "seed_type": "url",
    "seed_value": "https://www.quora.com/Is-AI-an-existential-threat-to-humanity",
    "source_url": "https://www.quora.com/Is-AI-an-existential-threat-to-humanity",
    "loaded_url": "https://www.quora.com/Is-AI-an-existential-threat-to-humanity",
    "scraped_at": "2026-06-30T12:00:00.000000Z",
    "search_type": "Question",
    "search_time_filter": "All Time"
  },
  "status": { "has_results": true, "note": "Direct Quora question URL loaded." },
  "url": "https://www.quora.com/Is-AI-an-existential-threat-to-humanity",
  "title": "Is AI an existential threat to humanity?",
  "metrics": { "answers": 42, "upvotes": 1180 },
  "posted_at": "2015-06-27T17:08:17.570000Z",
  "question": {
    "title": "Is AI an existential threat to humanity?",
    "url": "https://www.quora.com/Is-AI-an-existential-threat-to-humanity",
    "metrics": { "answers": 42 }
  },
  "answer": {
    "text": "Cleaned plain-text answer body...",
    "upvotes": 320,
    "posted_at": "2016-02-11T09:14:03.000000Z",
    "url": "https://www.quora.com/...",
    "author": { "name": "Jane Doe", "url": "https://www.quora.com/profile/Jane-Doe" }
  }
}
```

**Output record types you can expect from the Quora Scraper:**

- 🟦 **`topic`** — topic name, URL, follower count, photo, and flags.
- 🟩 **`space`** — Space name, description, follower/member counts, and icon.
- 🟨 **`question`** — title, URL, metrics, timestamp, and an optional embedded top answer.
- 🟧 **`answer`** — author, body text, upvotes, comments, views, and access option.

Every field is optional-safe: if Quora does not expose a value, the Quora Scraper simply omits it rather than inventing data. This makes the output stable and easy to validate downstream. ✅

***

#### ⚙️ How the Quora Scraper Works

Under the hood, the Quora Scraper follows a clear, layered strategy so it can adapt to whatever Quora returns.

##### 🔍 URL Classification

Every start URL is classified first. The Quora Scraper detects whether a link is a **search page**, a **Space**, a **Topic**, a **Profile**, or a **Question**, and then routes it to the correct handler. This means you can throw a mixed list of URLs at the Quora Scraper and it will sort them out automatically. 🧭

##### 🧬 Embedded JSON Recovery

Quora ships much of its data as JSON embedded inside the page — sometimes double-encoded, sometimes streamed through registration payloads. The Quora Scraper extracts these blobs using a combination of **brace-balancing**, **push-payload decoding**, and **JSON-LD parsing**, then walks the structures to pull out only the typed nodes you asked for. No JavaScript engine is needed for direct pages. 🧠

##### 🧠 Search via Persisted Query

The search tab is rendered client-side, so static HTML alone will not contain results. To handle this, the Quora Scraper reproduces the same internal API call the website makes: it resolves the persisted query identifier, extracts the form key, and paginates through results until it has enough records. Because search is gated, **logged-in cookies** are required for real search output. 🔐

##### 🖥️ Optional Render Mode

When you truly need JavaScript-rendered search results and prefer not to manage cookies, you can enable the optional render mode. The Quora Scraper will load the page with a real browser engine, capture the network responses that contain the data, and feed them back into the same extraction pipeline. This is opt-in and off by default to keep the Quora Scraper fast.

***

#### 🛠️ Setup & Usage

Getting the Quora Scraper running takes only a couple of minutes. 🕐

##### 📦 Install Dependencies

```bash
pip install curl_cffi cloudscraper requests parsel beautifulsoup4
```

For optional render mode:

```bash
pip install playwright
python -m playwright install chromium
```

All of these are optional in the sense that the Quora Scraper degrades gracefully — if a library is missing, it falls back to the next available backend instead of failing to start. 🧰

##### ▶️ Run It

```bash
python app.py                       # uses the built-in INPUT
python app.py --input input.json    # supply your own configuration
python app.py --out output.json     # choose where results are written
python app.py --pretty              # also print results to the screen
```

After a run, the Quora Scraper writes a JSON file containing every record it collected and prints a short summary telling you how many records were produced.

##### 🧪 Debug & Offline Modes

The Quora Scraper includes a few helpful flags for development:

- `--debug` 🐞 prints the node types and keys it discovers.
- `--dump-dir` 💾 saves every fetched page so you can tune parsing offline.
- `--from-html` 📂 parses a previously saved page without making any network calls.

These make the Quora Scraper easy to test and extend without hammering the live site.

***

#### 🔓 Handling Search & Authentication

Search is the one area where the Quora Scraper needs your help. Quora serves search results only to authenticated sessions, so an anonymous run returns an empty connection. There are three reliable ways to fix this:

1. 🍪 **Paste cookies** — copy your logged-in session cookies into the `cookies` field.
2. 👤 **Reuse a browser profile** — point `chromeUserDataDir` at an existing profile so the Quora Scraper inherits both your login and your clearance.
3. 🖥️ **Enable render mode** — switch `useBrowser` on for JavaScript-heavy pages.

For **direct Topic, Space, and Question URLs**, none of this is required — the Quora Scraper will collect data out of the box. 🎉

***

#### 🌍 Proxies & Anti-Blocking

Quora sits behind a protection layer, so a good proxy dramatically improves success rates. The Quora Scraper is built with this reality in mind:

- 🧷 **Sticky sessions** — when a rotating residential proxy is detected, the Quora Scraper pins a single exit IP for the whole run so the page fetch and the follow-up API call share the same address.
- 🔄 **Backend rotation** — browser-grade TLS fingerprints are tried first, since generic clients are commonly blocked.
- ⏱️ **Polite pacing** — a short delay between URLs keeps the Quora Scraper respectful and reduces the chance of throttling.

A **residential proxy** is strongly recommended for the most consistent results from the Quora Scraper. 🌐

***

#### 📚 Output Schema Reference

Here is a quick map of the most useful fields the Quora Scraper produces:

##### 🏷️ Common Fields

- `record_type` — the kind of record.
- `url` — the canonical link.
- `title` — the human-readable title or name.
- `status` — whether results were found and an explanatory note.
- `source_context` — the seed, the loaded URL, and the scrape timestamp.

##### 📈 Metrics

Depending on the record, the Quora Scraper may include follower counts, member counts, answer counts, upvotes, comment counts, share counts, and view counts. All metrics are numeric and omitted when unavailable.

##### 🕒 Timestamps

The Quora Scraper normalizes every timestamp into ISO-8601 format with microsecond precision and a trailing `Z`, regardless of whether Quora stored it as seconds, milliseconds, microseconds, or an ISO string. This keeps your dataset perfectly consistent. ✅

***

#### ❓ Frequently Asked Questions

##### Does the Quora Scraper need a browser?

No. For direct URLs the Quora Scraper uses pure HTTP. A browser is only optional, for JavaScript-rendered search pages.

##### Why is my search empty?

Search is gated. Add logged-in cookies or reuse a browser profile, and the Quora Scraper will return real results.

##### Can the Quora Scraper handle many URLs at once?

Yes. Pass a list in `startUrls` and the Quora Scraper processes each one, classifies it, and merges all records into a single output file.

##### What format does the Quora Scraper output?

Clean, normalized JSON — ready for spreadsheets, databases, or analytics tools. 📊

***

#### 🎯 Final Notes

The **Quora Scraper** is a focused, no-nonsense tool for turning public Quora content into structured data. It is fast because it avoids a browser, resilient because it rotates backends and retries intelligently, and flexible because it accepts any mix of search, Space, Topic, and Question URLs. Whether you are a researcher, a marketer, a data engineer, or a curious builder, the Quora Scraper gives you a clean, repeatable way to collect the information you need.

Please use the Quora Scraper responsibly: scrape only public data, respect rate limits, and follow the terms and local laws that apply to you. Used wisely, the Quora Scraper is a powerful addition to your data toolkit. 🚀

# Actor input Schema

## `startUrls` (type: `array`):

Quora URLs to scrape. Supports search pages (https://www.quora.com/search?q=...), question URLs, topic URLs (/topic/...), profile URLs (/profile/...) and space subdomains (https://name.quora.com/).

## `searchType` (type: `string`):

Which result type to request for search seeds.

## `timeFilter` (type: `string`):

Restrict search results by recency.

## `maxItemsPerQuery` (type: `integer`):

Maximum number of records to collect per search seed.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.quora.com/search?q=pool"
    },
    {
      "url": "https://humanity.quora.com/"
    },
    {
      "url": "https://www.quora.com/Is-AI-an-existential-threat-to-humanity"
    }
  ],
  "searchType": "Question",
  "timeFilter": "All Time",
  "maxItemsPerQuery": 10
}
```

# 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 = {
    "startUrls": [
        {
            "url": "https://www.quora.com/search?q=pool"
        },
        {
            "url": "https://humanity.quora.com/"
        },
        {
            "url": "https://www.quora.com/Is-AI-an-existential-threat-to-humanity"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapers-hub/quora-scraper-no-cookies").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 = { "startUrls": [
        { "url": "https://www.quora.com/search?q=pool" },
        { "url": "https://humanity.quora.com/" },
        { "url": "https://www.quora.com/Is-AI-an-existential-threat-to-humanity" },
    ] }

# Run the Actor and wait for it to finish
run = client.actor("scrapers-hub/quora-scraper-no-cookies").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 '{
  "startUrls": [
    {
      "url": "https://www.quora.com/search?q=pool"
    },
    {
      "url": "https://humanity.quora.com/"
    },
    {
      "url": "https://www.quora.com/Is-AI-an-existential-threat-to-humanity"
    }
  ]
}' |
apify call scrapers-hub/quora-scraper-no-cookies --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Quora Scraper | No Cookies | $1 / 1K",
        "description": "Quora scraper to extract publicly available questions, answers, topics, author profiles, engagement metrics, and other Quora data—no cookies required 💬📊 Perfect for market research, content analysis, SEO research, trend discovery, and AI datasets.",
        "version": "0.1",
        "x-build-id": "O6G01CS6w1bcXeyqP"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapers-hub~quora-scraper-no-cookies/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapers-hub-quora-scraper-no-cookies",
                "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/scrapers-hub~quora-scraper-no-cookies/runs": {
            "post": {
                "operationId": "runs-sync-scrapers-hub-quora-scraper-no-cookies",
                "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/scrapers-hub~quora-scraper-no-cookies/run-sync": {
            "post": {
                "operationId": "run-sync-scrapers-hub-quora-scraper-no-cookies",
                "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",
                "required": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Quora URLs to scrape. Supports search pages (https://www.quora.com/search?q=...), question URLs, topic URLs (/topic/...), profile URLs (/profile/...) and space subdomains (https://name.quora.com/).",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "searchType": {
                        "title": "Search type",
                        "enum": [
                            "Question",
                            "Answer",
                            "Topic",
                            "Space",
                            "Profile",
                            "All"
                        ],
                        "type": "string",
                        "description": "Which result type to request for search seeds.",
                        "default": "Question"
                    },
                    "timeFilter": {
                        "title": "Time filter",
                        "enum": [
                            "All Time",
                            "Past Day",
                            "Past Week",
                            "Past Month",
                            "Past Year"
                        ],
                        "type": "string",
                        "description": "Restrict search results by recency.",
                        "default": "All Time"
                    },
                    "maxItemsPerQuery": {
                        "title": "Max items per query",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of records to collect per search seed.",
                        "default": 10
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```