# Stack Exchange Questions & Answers Scraper (`automation-lab/stack-exchange-questions-answers-scraper`) Actor
Extract public Stack Overflow and Stack Exchange Q\&A with answers, comments, tags, owners, scores, views, and URLs for research or RAG.
- **URL**: https://apify.com/automation-lab/stack-exchange-questions-answers-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet
## Pricing
Pay per event
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
## Stack Exchange Questions & Answers Scraper
Extract Stack Overflow and Stack Exchange questions, answers, comments, tags, authors, scores, and view counts with the public Stack Exchange API.
Use this actor when you need reliable public Q&A data for developer community intelligence, support knowledge mining, technical content research, FAQ generation, or retrieval-augmented generation datasets.
### What does Stack Exchange Questions & Answers Scraper do?
Stack Exchange Questions & Answers Scraper searches Stack Overflow and other Stack Exchange sites through the official public API.
It returns one dataset row per question.
Each row can include the question body, tags, owner details, score, view count, answer count, accepted-answer status, timestamps, and optional nested answers and comments.
The actor supports keyword searches, tag searches, date filters, direct question URLs, and numeric question IDs.
Because it uses the public API, it does not need browser automation, login cookies, or residential proxies.
### Who is it for?
🧑💻 Developer relations teams can monitor questions about their SDKs, APIs, tools, and integrations.
🛟 Support teams can mine recurring public problems and convert them into docs, FAQs, and knowledge-base articles.
📚 Content teams can research developer pain points before writing tutorials or comparison pages.
🔎 Search and RAG teams can build public Q&A datasets with stable question URLs and answer text.
📈 Product teams can track score, view count, and answer-count signals around technical topics.
### Why use this actor?
It is focused on structured Q&A records, not raw HTML pages.
It works across configurable Stack Exchange sites such as `stackoverflow`, `serverfault`, `superuser`, `askubuntu`, `math`, `stats`, and many others.
It supports direct URL enrichment when you already have a list of questions.
It can collect answers and comments in the same question row for downstream analysis.
It honors Stack Exchange API backoff instructions and retries transient failures.
### What Stack Exchange sites are supported?
Use the Stack Exchange API `site` parameter.
Common values include:
- `stackoverflow`
- `serverfault`
- `superuser`
- `askubuntu`
- `math`
- `stats`
- `electronics`
- `security`
- `softwareengineering`
The default is `stackoverflow`.
### Data you can extract
| Field | Description |
| --- | --- |
| `site` | Stack Exchange API site value used for the run |
| `questionId` | Numeric Stack Exchange question ID |
| `questionUrl` | Canonical question URL |
| `title` | Question title |
| `body` | Question body HTML returned by the API |
| `tags` | Stack Exchange tags |
| `ownerDisplayName` | Public owner display name |
| `ownerUserId` | Public Stack Exchange user ID |
| `ownerReputation` | Owner reputation at fetch time |
| `ownerProfileUrl` | Owner profile URL |
| `score` | Question score |
| `viewCount` | Public view count |
| `answerCount` | Number of answers |
| `commentCount` | Number of comments |
| `isAnswered` | Whether the question is answered |
| `acceptedAnswerId` | Accepted answer ID when available |
| `creationDate` | Question creation date |
| `lastActivityDate` | Last activity date |
| `lastEditDate` | Last edit date |
| `closedDate` | Closed date when available |
| `closedReason` | Closed reason when available |
| `answers` | Optional nested answer objects |
| `comments` | Optional nested question comments |
| `fetchedAt` | Actor fetch timestamp |
### How much does it cost to scrape Stack Exchange questions?
The actor uses pay-per-event pricing.
There is a small start charge for each run and a per-question charge for each saved dataset item.
Current pricing is a $0.005 start event plus tiered per-question pricing. The BRONZE per-question price is $0.00003452, with lower per-question prices on higher usage tiers.
Keep `maxQuestions` small for exploratory runs.
Increase it when you are ready to build a larger dataset.
### Input options
#### `site`
The Stack Exchange API site parameter.
Default: `stackoverflow`.
#### `query`
Free-text query for question search.
Example: `apify web scraping`.
#### `tags`
One or more tags to match.
Example: `web-scraping`, `javascript`, or `python`.
#### `questionUrls`
Specific question URLs to enrich.
The actor extracts numeric question IDs from `/questions/{id}/...` URLs.
#### `questionIds`
Specific numeric question IDs from the selected site.
#### `fromDate` and `toDate`
Optional creation-date filters.
Use `YYYY-MM-DD` or a full ISO timestamp.
#### `sort` and `order`
Choose Stack Exchange API sorting.
Supported sorts: `activity`, `votes`, `creation`, `relevance`.
Supported orders: `desc`, `asc`.
#### `maxQuestions`
Maximum number of question records to save.
Each saved question is one dataset item.
#### `includeAnswers`
Fetch nested answers for every saved question.
This is enabled by default.
#### `includeComments`
Fetch nested question comments.
This is disabled by default because it increases API calls.
#### `apiKey`
Optional Stack Apps API key for higher quotas.
Anonymous API access works for small and medium runs.
### Example input: keyword and tag search
```json
{
"site": "stackoverflow",
"query": "apify web scraping",
"tags": ["web-scraping"],
"maxQuestions": 25,
"includeAnswers": true,
"includeComments": false,
"sort": "activity",
"order": "desc"
}
````
### Example input: direct question URLs
```json
{
"site": "stackoverflow",
"questionUrls": [
"https://stackoverflow.com/questions/11227809/why-is-processing-a-sorted-array-faster-than-processing-an-unsorted-array"
],
"includeAnswers": true,
"includeComments": true,
"maxQuestions": 10
}
```
### Example input: another Stack Exchange site
```json
{
"site": "serverfault",
"query": "nginx reverse proxy timeout",
"maxQuestions": 50,
"includeAnswers": true
}
```
### Example output
```json
{
"site": "stackoverflow",
"questionId": 123456,
"questionUrl": "https://stackoverflow.com/questions/123456/example",
"title": "Example Stack Overflow question",
"tags": ["javascript", "web-scraping"],
"ownerDisplayName": "Example user",
"score": 12,
"viewCount": 3456,
"answerCount": 3,
"isAnswered": true,
"answers": [
{
"answer_id": 987654,
"question_id": 123456,
"is_accepted": true,
"score": 8,
"body": "Example answer body
"
}
],
"fetchedAt": "2026-07-10T00:00:00.000Z"
}
```
### How to run
1. Choose a Stack Exchange `site`.
2. Enter a `query`, `tags`, direct question URLs, or question IDs.
3. Set `maxQuestions`.
4. Decide whether to include answers and comments.
5. Start the actor.
6. Export the dataset as JSON, CSV, Excel, XML, or HTML.
### Tips for better results
Use tags when you need high precision.
Use a broad query when you are discovering unknown terminology.
Use `sort: "votes"` when you want evergreen high-signal questions.
Use `sort: "activity"` when you want recent discussion.
Disable comments for broad runs unless comments are required.
Add an API key for larger recurring workflows.
### Integrations
Connect this actor to a vector database to build technical support retrieval datasets.
Send output to Google Sheets for community monitoring.
Load JSON exports into a data warehouse for trend analysis.
Trigger scheduled runs to monitor new questions about your product or SDK.
Use webhooks to notify developer relations teams when new matching questions appear.
### API usage with Node.js
```js
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/stack-exchange-questions-answers-scraper').call({
site: 'stackoverflow',
query: 'apify web scraping',
tags: ['web-scraping'],
maxQuestions: 25,
includeAnswers: true
});
console.log(run.defaultDatasetId);
```
### API usage with Python
```python
from apify_client import ApifyClient
import os
client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/stack-exchange-questions-answers-scraper').call(run_input={
'site': 'stackoverflow',
'query': 'apify web scraping',
'tags': ['web-scraping'],
'maxQuestions': 25,
'includeAnswers': True,
})
print(run['defaultDatasetId'])
```
### API usage with cURL
```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~stack-exchange-questions-answers-scraper/runs?token=$APIFY_TOKEN" \
-H 'Content-Type: application/json' \
-d '{"site":"stackoverflow","query":"apify web scraping","maxQuestions":25,"includeAnswers":true}'
```
### MCP usage
Use the Apify MCP server with this actor enabled.
Claude Code example:
```bash
claude mcp add apify https://mcp.apify.com/?tools=automation-lab/stack-exchange-questions-answers-scraper
```
Claude Desktop configuration:
```json
{
"mcpServers": {
"apify": {
"url": "https://mcp.apify.com/?tools=automation-lab/stack-exchange-questions-answers-scraper"
}
}
}
```
#### Example prompts
Use these prompts after adding `https://mcp.apify.com/?tools=automation-lab/stack-exchange-questions-answers-scraper` to your MCP client:
- "Run automation-lab/stack-exchange-questions-answers-scraper for recent Stack Overflow questions about Apify web scraping and summarize recurring issues."
- "Use the Stack Exchange Questions & Answers Scraper MCP tool to extract top-voted Server Fault questions about nginx proxy timeouts."
- "Call the scraper for questions tagged web-scraping, include answers, then build a JSON dataset of accepted-answer patterns."
- "Find Stack Overflow questions about Playwright timeouts from the last year and list the most common fixes."
### Rate limits and quotas
The Stack Exchange API applies quotas and may return a `backoff` instruction.
The actor waits when the API requests backoff.
Anonymous access is suitable for small and medium runs.
For larger recurring runs, add a Stack Apps API key.
### Dataset design
The actor stores one row per question.
Answers and comments are nested in the question row when enabled.
This keeps exports simple for knowledge-mining workflows.
It also avoids forcing users to join separate datasets before sending records to a search index or LLM pipeline.
### Common workflows
#### Developer community intelligence
Monitor new questions mentioning your product, SDK, or API.
Track which tags and error phrases appear most often.
Prioritize docs updates based on view counts and scores.
#### Support knowledge mining
Collect public questions and accepted answers around common errors.
Use output as seed material for internal support macros.
Identify outdated answers that may need official clarification.
#### Technical content research
Find high-vote questions before writing tutorials.
Review accepted answers and unanswered threads.
Use tags and date filters to understand topic evolution.
#### RAG and search datasets
Export question and answer bodies as JSON.
Clean HTML downstream if your embedding pipeline requires plain text.
Store question IDs and URLs for citation.
### Troubleshooting
#### The run returns no items
Check that your `site` value is valid.
Try a broader query or remove strict tags.
For direct URLs, make sure they belong to the selected `site`.
#### The API reports quota or throttling
Reduce `maxQuestions` for the current run.
Disable comments to reduce request volume.
Add a Stack Apps API key for higher quotas.
#### Dates do not work
Use `YYYY-MM-DD` or a full ISO timestamp.
The actor filters by question creation date.
#### Answers are missing
Make sure `includeAnswers` is enabled.
Some questions have no answers or deleted answers that the public API cannot return.
### Limitations
The actor returns public data exposed by the Stack Exchange API.
It cannot access deleted posts, private moderator data, or account-only content.
The question body and answer body are returned as HTML from the API.
Very large runs are subject to Stack Exchange API quotas.
### Legality and ethics
This actor uses the public Stack Exchange API.
Respect Stack Exchange API terms and attribution requirements.
Do not use the data to republish private or sensitive information.
Review your use case for privacy, copyright, and database-rights obligations.
### Related scrapers
Explore related Automation Lab actors for developer, content, and web data workflows:
- https://apify.com/automation-lab/github-marketplace-scraper
- https://apify.com/automation-lab/npm-package-intelligence-scraper
- https://apify.com/automation-lab/pubmed-search-scraper
- https://apify.com/automation-lab/webpage-text-extractor
### FAQ
#### Can I scrape Stack Overflow only?
Yes. Use the default `site` value, `stackoverflow`.
#### Can I scrape other Stack Exchange communities?
Yes. Set `site` to the API site value for that community.
#### Do I need a Stack Exchange account?
No. Anonymous public API access works for normal small runs.
#### Do I need proxies?
No. The actor calls the public API directly.
#### Can I include comments?
Yes. Enable `includeComments`, but remember that it increases API calls.
#### Can I monitor questions daily?
Yes. Schedule the actor with a query, tags, and date strategy that matches your monitoring workflow.
#### Can I use the data for RAG?
Yes. The output includes question URLs, titles, body HTML, answer bodies, and metadata suitable for downstream cleaning and indexing.
### Changelog
See the actor changelog for release notes.
# Actor input Schema
## `site` (type: `string`):
Stack Exchange API site parameter, such as stackoverflow, serverfault, superuser, math, stats, askubuntu, or electronics.
## `query` (type: `string`):
Free-text query for /search/advanced, for example apify crawling, vector database, or playwright timeout.
## `tags` (type: `array`):
Optional Stack Exchange tags to match. Multiple tags are ANDed by the Stack Exchange API.
## `questionUrls` (type: `array`):
Specific Stack Exchange question URLs to enrich with metadata, answers, and comments.
## `questionIds` (type: `array`):
Specific numeric question IDs from the selected site.
## `fromDate` (type: `string`):
Only include questions created on or after this date. Use YYYY-MM-DD or an ISO timestamp.
## `toDate` (type: `string`):
Only include questions created on or before this date. Use YYYY-MM-DD or an ISO timestamp.
## `sort` (type: `string`):
Stack Exchange search sort order.
## `order` (type: `string`):
Sort direction.
## `maxQuestions` (type: `integer`):
Maximum number of question records to save. Each saved question is one charged result.
## `includeAnswers` (type: `boolean`):
Fetch accepted and other public answers for each question and store them nested in the question row.
## `includeComments` (type: `boolean`):
Fetch public comments for each question. This increases API calls, so keep disabled for broad monitoring runs unless needed.
## `apiKey` (type: `string`):
Optional Stack Exchange API key for higher quotas. Anonymous API access works for small and medium runs.
## Actor input object example
```json
{
"site": "stackoverflow",
"query": "apify web scraping",
"tags": [
"web-scraping"
],
"sort": "activity",
"order": "desc",
"maxQuestions": 20,
"includeAnswers": true,
"includeComments": false
}
```
# Actor output Schema
## `overview` (type: `string`):
No description
## `details` (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 '' with your token
const client = new ApifyClient({
token: '',
});
// Prepare Actor input
const input = {
"site": "stackoverflow",
"query": "apify web scraping",
"tags": [
"web-scraping"
],
"sort": "activity",
"order": "desc",
"maxQuestions": 20,
"includeAnswers": true,
"includeComments": false
};
// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/stack-exchange-questions-answers-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 '' with your token.
client = ApifyClient("")
# Prepare the Actor input
run_input = {
"site": "stackoverflow",
"query": "apify web scraping",
"tags": ["web-scraping"],
"sort": "activity",
"order": "desc",
"maxQuestions": 20,
"includeAnswers": True,
"includeComments": False,
}
# Run the Actor and wait for it to finish
run = client.actor("automation-lab/stack-exchange-questions-answers-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 '{
"site": "stackoverflow",
"query": "apify web scraping",
"tags": [
"web-scraping"
],
"sort": "activity",
"order": "desc",
"maxQuestions": 20,
"includeAnswers": true,
"includeComments": false
}' |
apify call automation-lab/stack-exchange-questions-answers-scraper --silent --output-dataset
```
## MCP server setup
```json
{
"mcpServers": {
"apify": {
"command": "npx",
"args": [
"mcp-remote",
"https://mcp.apify.com/?tools=automation-lab/stack-exchange-questions-answers-scraper",
"--header",
"Authorization: Bearer "
]
}
}
}
```
## OpenAPI specification
```json
{
"openapi": "3.0.1",
"info": {
"title": "Stack Exchange Questions & Answers Scraper",
"description": "Extract public Stack Overflow and Stack Exchange Q&A with answers, comments, tags, owners, scores, views, and URLs for research or RAG.",
"version": "0.1",
"x-build-id": "uvFbSqo9yRYo1Ptrr"
},
"servers": [
{
"url": "https://api.apify.com/v2"
}
],
"paths": {
"/acts/automation-lab~stack-exchange-questions-answers-scraper/run-sync-get-dataset-items": {
"post": {
"operationId": "run-sync-get-dataset-items-automation-lab-stack-exchange-questions-answers-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/automation-lab~stack-exchange-questions-answers-scraper/runs": {
"post": {
"operationId": "runs-sync-automation-lab-stack-exchange-questions-answers-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/automation-lab~stack-exchange-questions-answers-scraper/run-sync": {
"post": {
"operationId": "run-sync-automation-lab-stack-exchange-questions-answers-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",
"required": [
"site",
"maxQuestions"
],
"properties": {
"site": {
"title": "🌐 Stack Exchange site",
"type": "string",
"description": "Stack Exchange API site parameter, such as stackoverflow, serverfault, superuser, math, stats, askubuntu, or electronics.",
"default": "stackoverflow"
},
"query": {
"title": "Search query",
"type": "string",
"description": "Free-text query for /search/advanced, for example apify crawling, vector database, or playwright timeout."
},
"tags": {
"title": "Tags",
"type": "array",
"description": "Optional Stack Exchange tags to match. Multiple tags are ANDed by the Stack Exchange API.",
"items": {
"type": "string"
}
},
"questionUrls": {
"title": "Question URLs",
"type": "array",
"description": "Specific Stack Exchange question URLs to enrich with metadata, answers, and comments.",
"items": {
"type": "string"
}
},
"questionIds": {
"title": "Question IDs",
"type": "array",
"description": "Specific numeric question IDs from the selected site.",
"items": {
"type": "string"
}
},
"fromDate": {
"title": "From date",
"type": "string",
"description": "Only include questions created on or after this date. Use YYYY-MM-DD or an ISO timestamp."
},
"toDate": {
"title": "To date",
"type": "string",
"description": "Only include questions created on or before this date. Use YYYY-MM-DD or an ISO timestamp."
},
"sort": {
"title": "Sort by",
"enum": [
"activity",
"votes",
"creation",
"relevance"
],
"type": "string",
"description": "Stack Exchange search sort order.",
"default": "activity"
},
"order": {
"title": "Order",
"enum": [
"desc",
"asc"
],
"type": "string",
"description": "Sort direction.",
"default": "desc"
},
"maxQuestions": {
"title": "Maximum questions",
"minimum": 1,
"maximum": 10000,
"type": "integer",
"description": "Maximum number of question records to save. Each saved question is one charged result.",
"default": 20
},
"includeAnswers": {
"title": "Include answers",
"type": "boolean",
"description": "Fetch accepted and other public answers for each question and store them nested in the question row.",
"default": true
},
"includeComments": {
"title": "Include question comments",
"type": "boolean",
"description": "Fetch public comments for each question. This increases API calls, so keep disabled for broad monitoring runs unless needed.",
"default": false
},
"apiKey": {
"title": "Stack Apps API key (optional)",
"type": "string",
"description": "Optional Stack Exchange API key for higher quotas. Anonymous API access works for small and medium runs."
}
}
},
"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
}
}
}
}
}
}
}
}
}
}
```