# Stack Overflow Scraper | Questions Answers and Tags (`parseforge/stackoverflow-scraper`) Actor

Extract questions, answers, votes, tags, authors, comments, and accepted answers from Stack Overflow. Search by topic or filter by tag to build developer Q\&A datasets, monitor trending technologies, or train AI coding assistants on real-world programming problems and solutions.

- **URL**: https://apify.com/parseforge/stackoverflow-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Developer tools, Social media, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $19.00 / 1,000 results

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

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

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 💬 Stack Overflow Scraper

> 🚀 **Export Stack Overflow questions, scores, tags, and author data in seconds.** No login required.

> 🕒 **Last updated:** 2026-05-21 · **📊 16 fields** per record · **Up to 1,000,000 questions** · **Stack Overflow (global)**

The Stack Overflow Scraper lets you extract questions from Stack Overflow using the official Stack Exchange public API v2.3. Search by keyword, filter by tags, sort by votes or recency, and download structured data instantly - no API key required for standard usage.

Stack Overflow hosts over 58 million questions spanning virtually every programming topic. This scraper gives you programmatic access to that knowledge base: question scores, answer counts, view counts, accepted answers, author reputation, tags, and more - all in clean JSON ready for CSV, Excel, or direct integration.

**Coverage:** All public Stack Overflow questions accessible via the Stack Exchange API. Covers millions of questions across thousands of tags, from JavaScript and Python to DevOps and machine learning. Every record includes 16 structured fields.

| Who uses it | Why |
|---|---|
| Developers | Track trends in frameworks and languages |
| Researchers | Study Q&A dynamics, tag co-occurrence, community patterns |
| Data scientists | Build NLP datasets from real technical questions |
| Tech recruiters | Identify in-demand skills by tag volume and score |
| Educators | Find top-voted questions for curriculum building |
| Product managers | Benchmark competitor pain points and developer friction |

### 📋 What the Stack Overflow Scraper does

- Search questions by keyword (title match) across all of Stack Overflow
- Filter questions by one or more tags (e.g. `javascript`, `python,pandas`)
- Browse top-voted, most active, or newest questions without a search query
- Sort results by votes, activity, creation date, or relevance
- Capture full metadata: score, answer count, view count, accepted answer ID, bounty amount
- Extract author details: display name and reputation score
- Paginate automatically to hit your exact `maxItems` target

> 💡 **Why it matters:** Stack Overflow is the world's largest developer Q&A platform. Bulk access to its question data unlocks trend analysis, skill mapping, content research, and NLP dataset construction - none of which are possible through the website UI alone.

### 🎬 Full Demo

🚧 Coming soon

### ⚙️ Input

| Field | Type | Description | Default |
|---|---|---|---|
| `searchQuery` | string | Search for questions by title keywords | `javascript async await` |
| `maxItems` | integer | Max questions to return (free: 10, paid: up to 1,000,000) | `10` |
| `tags` | string | Comma-separated tags to filter by, e.g. `javascript,python` | `javascript` |
| `sortBy` | select | Sort order: votes, activity, creation, relevance | `votes` |
| `apiKey` | string | Optional free API key from stackapps.com for 10,000 req/day | - |

**JSON example - search by keyword:**
```json
{
  "searchQuery": "javascript async await",
  "sortBy": "votes",
  "maxItems": 50
}
````

**JSON example - filter by tags:**

```json
{
  "tags": "python,pandas",
  "sortBy": "activity",
  "maxItems": 100
}
```

> ⚠️ **Good to Know:** The Stack Exchange API returns up to 300 requests/day without an API key. For large exports, grab a free key at [stackapps.com](https://stackapps.com/apps/oauth/register) and paste it in the `apiKey` field to unlock 10,000 requests/day. Each page fetches up to 100 questions, so 300 requests covers 30,000 items without a key.

### 📊 Output

| Field | Type | Description |
|---|---|---|
| 📌 `title` | string | Question title (HTML-decoded) |
| 🔗 `url` | string | Direct link to the question |
| 🆔 `questionId` | integer | Stack Overflow question ID |
| ⬆️ `score` | integer | Net upvotes minus downvotes |
| 💬 `answerCount` | integer | Number of answers posted |
| 👁️ `viewCount` | integer | Total views |
| ✅ `isAnswered` | boolean | Whether question has an accepted or highly-voted answer |
| 🏆 `acceptedAnswerId` | integer | ID of the accepted answer (null if none) |
| 🏷️ `tags` | array | List of tag slugs |
| 👤 `author` | string | Display name of the question author |
| ⭐ `authorReputation` | integer | Author's Stack Overflow reputation score |
| 💰 `bountyAmount` | integer | Active bounty amount (null if no bounty) |
| 📅 `createdAt` | string | ISO 8601 creation timestamp |
| 🕒 `lastActivityAt` | string | ISO 8601 last activity timestamp |
| 🔄 `scrapedAt` | string | ISO 8601 scrape timestamp |
| ❌ `error` | string | Error message if scraping failed (null otherwise) |

**Sample records (real output):**

```json
[
  {
    "title": "javascript : Async/await in .replace",
    "url": "https://stackoverflow.com/questions/33631041/javascript-async-await-in-replace",
    "questionId": 33631041,
    "score": 45,
    "answerCount": 9,
    "viewCount": 21472,
    "isAnswered": true,
    "acceptedAnswerId": null,
    "tags": ["javascript", "async-await", "es6-promise", "ecmascript-2016"],
    "author": "ritz078",
    "authorReputation": 2367,
    "bountyAmount": null,
    "createdAt": "2015-11-10T13:23:33.000Z",
    "lastActivityAt": "2024-12-15T03:37:58.000Z",
    "scrapedAt": "2026-05-22T01:25:13.303Z",
    "error": null
  },
  {
    "title": "javascript async/await not working",
    "url": "https://stackoverflow.com/questions/43359528/javascript-async-await-not-working",
    "questionId": 43359528,
    "score": 33,
    "answerCount": 2,
    "viewCount": 88921,
    "isAnswered": true,
    "acceptedAnswerId": 43359856,
    "tags": ["javascript", "async-await"],
    "author": "noobie",
    "authorReputation": 2617,
    "bountyAmount": null,
    "createdAt": "2017-04-12T03:04:08.000Z",
    "lastActivityAt": "2019-03-15T20:36:26.000Z",
    "scrapedAt": "2026-05-22T01:25:13.303Z",
    "error": null
  },
  {
    "title": "Why does this JavaScript async/await code not behave as expected?",
    "url": "https://stackoverflow.com/questions/47796000/why-does-this-javascript-async-await-code-not-behave-as-expected",
    "questionId": 47796000,
    "score": 13,
    "answerCount": 4,
    "viewCount": 1242,
    "isAnswered": true,
    "acceptedAnswerId": 47796089,
    "tags": ["javascript", "asynchronous", "async-await"],
    "author": "HanifC",
    "authorReputation": 175,
    "bountyAmount": null,
    "createdAt": "2017-12-13T14:54:37.000Z",
    "lastActivityAt": "2017-12-13T15:08:03.000Z",
    "scrapedAt": "2026-05-22T01:25:13.303Z",
    "error": null
  }
]
```

### ✨ Why choose this Actor

| Feature | Benefit |
|---|---|
| 🏛️ Official Stack Exchange API | Stable, documented, rate-limit-aware - no scraping fragility |
| 🔍 Keyword + tag search | Two distinct search modes for flexible targeting |
| 📄 Automatic pagination | Reaches your exact `maxItems` without manual page management |
| 🔑 Optional API key support | Scale to 10,000 requests/day with a free stackapps.com key |
| 🧹 HTML-decoded titles | No raw `&` entities in your data |
| 📊 16 structured fields | Score, reputation, bounty, timestamps - everything the API offers |
| 🌐 No login required | Runs on the public API - always available |

### 📈 How it compares to alternatives

| | This Actor | Manual browsing | Custom script |
|---|---|---|---|
| Bulk export | Up to 1M items | Impractical | Requires dev time |
| No login | Yes | Yes | Depends |
| Structured JSON | Yes | Copy-paste | Yes |
| Pagination handled | Automatic | Manual | Manual |
| Cloud-ready | Yes | No | No |
| Tag + keyword filters | Both supported | Limited | Depends |

### 🚀 How to use

1. [Create a free account w/ $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp) on Apify
2. Open the **Stack Overflow Scraper** actor page
3. Enter a `searchQuery` (e.g. `react hooks`) or a tag list (e.g. `python,numpy`)
4. Set `maxItems` and optional `sortBy`
5. Click **Run** - results appear in the dataset within seconds
6. Download as JSON, CSV, Excel, or XML

### 💼 Business use cases

#### Developer Relations and Community Analysis

Map the most-asked questions around your product's technology stack. Track score trends over time to see which developer pain points are growing. Use `tags` to scope to your SDK, library, or framework. Identify power users by `authorReputation`.

#### Recruiting and Skill Intelligence

Filter by technology tags to find which questions are most viewed and answered - a proxy for community depth and talent supply. Compare tag volumes across languages and frameworks to inform hiring roadmaps.

#### Content Marketing and SEO

Find the highest-voted unanswered or low-answer-count questions in your niche. These are content gaps: blog posts, tutorials, and documentation that your team can own. Sort by `viewCount` to prioritize reach.

#### Academic and NLP Research

Build labeled Q\&A datasets from real developer questions. Filter by `isAnswered` and `acceptedAnswerId` for clean positive examples. Use `score` as a quality signal for training data curation.

### 🔌 Automating Stack Overflow Scraper

Connect to your workflow in minutes:

- **Make (Integromat):** Schedule daily runs via webhook, pipe results into Google Sheets or Airtable
- **Zapier:** Trigger on actor completion, push new questions to Slack, Notion, or a database
- **Apify Scheduler:** Set up recurring runs (hourly, daily, weekly) without any code
- **REST API:** `POST /v2/acts/parseforge~stackoverflow-scraper/runs` - integrate directly from any backend

### 🌟 Beyond business use cases

#### Research and Academia

Study how programming knowledge evolves on Stack Overflow. Analyze tag co-occurrence networks, measure question lifecycle (creation to accepted answer), or track how `authorReputation` correlates with answer quality.

#### Creative Projects

Build a daily "question of the day" bot. Create a browser extension that surfaces related Stack Overflow questions based on your current code file. Generate trivia games from top-voted questions.

#### Non-Profit and Education

Curate free learning resources by extracting the highest-voted questions and answers in beginner-friendly tags like `python` or `html`. Build offline reference packs for coding bootcamps with limited connectivity.

#### Experimentation

Test NLP models on real technical text. Evaluate semantic similarity between question titles. Build a recommendation engine that suggests questions based on tag overlap and score signals.

### 🤖 Ask an AI assistant about this scraper

Not sure which inputs to use? Paste this into any AI assistant:

> "I'm using the ParseForge Stack Overflow Scraper on Apify. It exports questions from Stack Overflow via the Stack Exchange API. I want to \[describe your goal]. What input configuration should I use?"

### ❓ Frequently Asked Questions

**❓ Do I need a Stack Overflow account?**
No. The Stack Exchange API is fully public. No login, no OAuth, no credentials required.

**❓ What is the rate limit?**
Without an API key: 300 requests/day. Each request fetches up to 100 questions, so that's 30,000 questions/day. With a free API key from stackapps.com: 10,000 requests/day (1,000,000 questions/day).

**❓ How do I get an API key?**
Register a free app at [stackapps.com/apps/oauth/register](https://stackapps.com/apps/oauth/register). You'll get a key immediately. Paste it into the `apiKey` input field.

**❓ Can I scrape other Stack Exchange sites?**
The current actor is scoped to Stack Overflow. The underlying API supports all Stack Exchange sites - contact ParseForge if you need a version targeting Server Fault, Super User, or other communities.

**❓ What's the difference between searchQuery and tags?**
`searchQuery` searches question titles for matching keywords (uses the `/search` endpoint). `tags` filters by exact tag slugs (uses the `/questions?tagged=` endpoint). If you provide both, `searchQuery` takes priority.

**❓ What does sortBy "relevance" do?**
Relevance ranking is only meaningful with a `searchQuery`. It ranks results by how well the title matches your search terms. Without a search query, the actor falls back to votes.

**❓ Are deleted or closed questions included?**
No. The public API only returns visible, active questions.

**❓ Why is `acceptedAnswerId` null on some records?**
Not every question has an accepted answer. The field is null when the asker hasn't accepted any answer yet.

**❓ Why is `bountyAmount` null on most records?**
Active bounties are rare - only questions with an open bounty at scrape time have a non-null value.

**❓ How do I scrape questions from a specific time range?**
The Stack Exchange API supports `fromdate` and `todate` Unix timestamp filters. Contact ParseForge to request a version with date range inputs.

**❓ Is the data real-time?**
Yes. Every run fetches live data from the Stack Exchange API. Results reflect the current state of Stack Overflow at scrape time.

**❓ Can I run this on a schedule?**
Yes. Use Apify Scheduler to run daily, weekly, or on any cron interval. Results accumulate in your dataset automatically.

### 🔌 Integrate with any app

Export your dataset directly to: Google Sheets, Airtable, Notion, PostgreSQL, MongoDB, BigQuery, Snowflake, Redshift, S3, Excel, CSV, XML, JSON, REST API, GraphQL, Make, Zapier, n8n, Slack, Discord, HubSpot, Salesforce, and more.

### 🔗 Recommended Actors

| Actor | Description |
|---|---|
| [Hacker News Scraper](https://apify.com/parseforge/hacker-news-scraper) | Export Hacker News stories, scores, and comment counts |
| [Dev.to Scraper](https://apify.com/parseforge/dev-to-scraper) | Scrape articles and author data from Dev.to |
| [GitHub Trending Scraper](https://apify.com/parseforge/github-trending-scraper) | Extract trending repositories from GitHub |

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for 100+ datasets across tech, finance, jobs, and more.

***

*This actor uses the Stack Exchange public API and complies with its terms of service. Stack Overflow data is provided under CC BY-SA 4.0. ParseForge is not affiliated with Stack Overflow or Stack Exchange.*

# Actor input Schema

## `searchQuery` (type: `string`):

Search for questions by title keywords. If provided, uses the search endpoint.

## `maxItems` (type: `integer`):

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

## `tags` (type: `string`):

Comma-separated tags to filter questions, e.g. javascript,python. Used when no search query is provided.

## `sortBy` (type: `string`):

How to sort the results.

## `apiKey` (type: `string`):

Free API key from stackapps.com for higher rate limits (10,000 requests/day vs 300/day without a key).

## Actor input object example

```json
{
  "searchQuery": "javascript async await",
  "maxItems": 10,
  "tags": "javascript",
  "sortBy": "votes"
}
```

# Actor output Schema

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

No description

# 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 = {
    "searchQuery": "javascript async await",
    "maxItems": 10,
    "tags": "javascript"
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/stackoverflow-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 = {
    "searchQuery": "javascript async await",
    "maxItems": 10,
    "tags": "javascript",
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/stackoverflow-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 '{
  "searchQuery": "javascript async await",
  "maxItems": 10,
  "tags": "javascript"
}' |
apify call parseforge/stackoverflow-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Stack Overflow Scraper | Questions Answers and Tags",
        "description": "Extract questions, answers, votes, tags, authors, comments, and accepted answers from Stack Overflow. Search by topic or filter by tag to build developer Q&A datasets, monitor trending technologies, or train AI coding assistants on real-world programming problems and solutions.",
        "version": "0.1",
        "x-build-id": "de1mT3Msu400CWrkF"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~stackoverflow-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-stackoverflow-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/parseforge~stackoverflow-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-stackoverflow-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/parseforge~stackoverflow-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-stackoverflow-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": {
                    "searchQuery": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Search for questions by title keywords. If provided, uses the search endpoint."
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    },
                    "tags": {
                        "title": "Tags",
                        "type": "string",
                        "description": "Comma-separated tags to filter questions, e.g. javascript,python. Used when no search query is provided."
                    },
                    "sortBy": {
                        "title": "Sort By",
                        "enum": [
                            "votes",
                            "activity",
                            "creation",
                            "relevance"
                        ],
                        "type": "string",
                        "description": "How to sort the results.",
                        "default": "votes"
                    },
                    "apiKey": {
                        "title": "API Key (optional)",
                        "type": "string",
                        "description": "Free API key from stackapps.com for higher rate limits (10,000 requests/day vs 300/day without a key)."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```