# Google Forums API (`johnvc/google-forums-search-api`) Actor

Extract forum threads, Q\&A, and community discussions from Google Search’s "Forums" tab. Supports 40+ countries, custom localization (GL/HL), and pagination. Get structured JSON data from Reddit, LinkedIn, Quora, and niche forums for sentiment analysis, market research, or AI training.

- **URL**: https://apify.com/johnvc/google-forums-search-api.md
- **Developed by:** [John](https://apify.com/johnvc) (community)
- **Categories:** SEO tools, Social media, AI
- **Stats:** 39 total users, 12 monthly users, 99.1% runs succeeded, 0 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $0.00001 / actor start

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## Google Forums API - Forum Threads, Q&A and Discussion Scraper

Extract forum threads, Q&A, and community discussions from Google Search's "Forums" tab. Supports 40+ countries, custom localization (GL/HL), and pagination. Get structured JSON from Reddit, LinkedIn, Quora, and niche forums for sentiment analysis, market research, AI training, and SEO research.

This Apify Actor wraps the Google Forums search experience as a clean JSON API. One dataset item is returned per page of results, with stable field names, deterministic pagination, and pay-per-event pricing.

**Python + MCP example:** [Apify-Google-Forums-Scraper on GitHub](https://github.com/johnisanerd/Apify-Google-Forums-Scraper)

---

### What this Actor returns

Each dataset item is one page of Google Forums results and contains:

- `search_parameters` - the effective query, location, country (`gl`), language (`hl`), filters, device, and `max_pages` used.
- `search_metadata` - `total_results`, `forums_count`, `pages_processed`, `max_pages_set`, `pagination_limit_reached`.
- `search_information` - the displayed query and the organic-results state from Google.
- `search_timestamp` - ISO-8601 timestamp of the extraction.
- `page_number` - 1-based page index.
- `forum_results` - an array of forum entries with `position`, `title`, `link`, `displayed_meta` (comments and recency), `source` (site or subreddit), `snippet`, and `date`.

What sets it apart:

- One stable JSON contract for every supported country and language.
- Localization with both `gl` (country) and `hl` (language); regional language variants like `en-gb` are normalized to base codes automatically.
- Filters for auto-corrected queries (`nfpr`) and duplicate content (`filter`).
- Device emulation (desktop, mobile, tablet).
- Honest, transparent pay-per-event pricing - setup plus one charge per page actually pushed.

---

### Use cases

- Monitor brand or product sentiment across Reddit, Quora, LinkedIn, and niche forums for a given keyword.
- Build training data or RAG corpora from real-world discussions about a topic.
- Track localized community conversations by country and language (e.g. coffee brewing discussions in Austin, US; AI jobs discussions in Tokyo, JP).
- Compare technology, product, or career questions across regions (e.g. "python vs java" in US vs IN vs DE).
- Extract thread metadata for indexing, NLP pipelines, competitive intelligence, and editorial research.

---

### Input parameters

The full input schema lives in [`input_schema.json`](.actor/input_schema.json) and renders automatically in the Apify UI. Key fields:

| Field | Type | Required | Default | What it does |
|---|---|---|---|---|
| `q` | string | **yes** | - | Forum search query (e.g. `python vs java`, `best coffee brewing methods`). |
| `location` | string | no | - | Human-readable location string for localized results (e.g. `Austin, TX, Texas, United States`). |
| `gl` | string (enum) | no | - | Country code (ISO 3166-1 alpha-2, lowercase). Top 40 high-traffic markets exposed in the UI. |
| `hl` | string (enum) | no | - | Interface language code (ISO 639-1, lowercase). Regional variants like `en-gb` normalize to `en`. |
| `lr` | string | no | - | Result-language restriction (e.g. `lang_en`, `lang_es`). |
| `safe` | string (enum) | no | `off` | `active` to filter explicit results, `off` to disable filtering. |
| `nfpr` | string (enum) | no | `0` | `0` includes auto-corrected results, `1` excludes them. |
| `filter` | string (enum) | no | `0` | `0` includes duplicates, `1` filters them. |
| `device` | string (enum) | no | `desktop` | `desktop`, `mobile`, or `tablet`. |
| `max_pages` | integer | no | `1` | Number of pages to fetch. `0` means no limit. Each processed page is one billable event. |
| `output_file` | string | no | auto | Optional filename for the combined JSON in the default key-value store. |

---

### Example inputs

#### 1. Basic forums search

```json
{
  "q": "what is the best programming language",
  "max_pages": 1
}
````

#### 2. Localized forums search

```json
{
  "q": "best coffee brewing methods forum",
  "location": "Austin, TX, Texas, United States",
  "gl": "us",
  "hl": "en",
  "max_pages": 1
}
```

#### 3. Multi-page search with filters

```json
{
  "q": "technology trends 2026",
  "gl": "us",
  "hl": "en",
  "nfpr": "1",
  "filter": "1",
  "device": "desktop",
  "max_pages": 2
}
```

#### 4. All available pages

```json
{
  "q": "python vs java web development",
  "gl": "us",
  "hl": "en",
  "max_pages": 0
}
```

***

### Example output

```json
{
  "search_parameters": {
    "q": "what is the best programming language",
    "location": null,
    "gl": "us",
    "hl": "en",
    "lr": null,
    "nfpr": 1,
    "filter": 1,
    "device": "desktop",
    "max_pages": 2
  },
  "search_metadata": {
    "total_results": 42,
    "forums_count": 20,
    "pages_processed": 2,
    "max_pages_set": 2,
    "pagination_limit_reached": true
  },
  "search_information": {
    "query_displayed": "what is the best programming language",
    "organic_results_state": "Results for exact spelling"
  },
  "search_timestamp": "2026-05-11T10:30:00.123456",
  "page_number": 1,
  "forum_results": [
    {
      "position": 1,
      "title": "For you what is the best programming language?",
      "link": "https://www.reddit.com/r/learnprogramming/comments/14o4uqz/for_you_what_is_the_best_programming_language_w/",
      "displayed_meta": "70+ comments . 2 years ago",
      "source": "Reddit . r/learnprogramming",
      "snippet": "C++ It's the biggest language in the world until now...",
      "date": "2 years ago"
    }
  ]
}
```

See [`dataset_schema.json`](.actor/dataset_schema.json) for the full schema.

***

### Pricing

Pay-per-event:

- **Setup** - one-time fee per Actor run. Covers initialization.
- **Page Processed** - one event per successfully pushed page of forum results (about 10 results per page).

At the start of each run, the Actor estimates the maximum possible cost (`setup + page_price * pages_to_check`) and aborts with a friendly `InsufficientFunds` dataset entry if the projected cost exceeds your remaining budget. No partial charges. If a page fails to push, it is not charged.

When the `PRODUCTION` environment variable is not set to `true`, the Actor runs in local-testing mode and only logs what it would charge.

***

### How to get started

1. Open the Actor in the Apify Store: https://apify.com/johnvc/google-forums-search-api
2. Click "Try for free", paste an input like the examples above, and run it.
3. Read results from the default dataset (table, JSON, or CSV export).
4. To run from the API, copy the run-via-API snippet in the Apify console.

For agents, this Actor is also discoverable through the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp) - search for "google forums" and call it as a tool.

To run locally:

```bash
cd ApifyGoogleForums
apify run --input '{
  "q": "what is the best programming language",
  "gl": "us",
  "hl": "en",
  "max_pages": 1
}'
```

For production charging, set `PRODUCTION=true` in the Actor's environment.

***

### FAQ and troubleshooting

**I got an empty `forum_results` array. Why?**
The query may be too niche, or Google Forums had nothing to return for that location and language combination. The `search_metadata.forums_count` will be `0` and the run still completes cleanly. The setup fee is charged once; no page events are billed.

**My country code is not in the dropdown.**
Only the top 40 highest-traffic markets are exposed in the UI for clarity and MCP-compatibility. To use any other ISO 3166-1 alpha-2 code, omit `gl` and pass a more specific `location` string instead - Google Forums localizes well from a city or region name.

**I want regional English (en-gb, en-us, en-au).**
The underlying API supports base language codes reliably. The Actor automatically normalizes regional variants to their base code (e.g. `en-gb` becomes `en`) and logs a warning when it does so. For region targeting, combine the base `hl` with a `gl` country code or a `location` string.

**My run aborted with "Insufficient funds".**
The Actor pre-checks the maximum projected cost (`setup + page_price * max_pages`) against your account's remaining charge limit. Either raise the account or run-level charge limit, or lower `max_pages`.

**Charging seems off.**
In local testing mode (no `PRODUCTION=true`), nothing is charged - the log lines describe what *would* be charged in production. In production, only successfully pushed pages count toward `page_processed`; failed pages do not bill.

**The actor returned "Error" but I still got some data.**
Google Forums occasionally stops returning further results during pagination. The Actor pushes the partial results it did get, logs the error, and writes a structured error entry to the dataset so downstream consumers can see what happened.

***

### Links

- Apify Store page: https://apify.com/johnvc/google-forums-search-api
- Apify MCP integration: https://docs.apify.com/platform/integrations/mcp
- Apify Actor definition reference: https://docs.apify.com/platform/actors/development/actor-definition/actor-json
- Quality Score and pricing transparency: https://docs.apify.com/platform/actors/publishing/quality-score

***

### n8n integration

Available as an n8n community node, **[n8n-nodes-google-forums-api](https://www.npmjs.com/package/n8n-nodes-google-forums-api)**. In n8n: Settings, Community Nodes, install `n8n-nodes-google-forums-api`, then use it in any workflow (it also works as an AI Agent tool).

***

### Featured Tasks

Ready-to-run examples that show this API solving a specific problem. Each opens its own setup so you can
run it on your account in one click.

- [Find Reddit threads mentioning your brand](https://apify.com/johnvc/google-forums-search-api/examples/find-reddit-threads-mentioning-your-brand?fpr=9n7kx3) - Reddit threads about any brand with title, link, and snippet, no Reddit API.
- [Scrape Google forums and discussions results](https://apify.com/johnvc/google-forums-search-api/examples/scrape-google-forums-and-discussions-results?fpr=9n7kx3) - Discussions and Forums tab results with thread title, source, and snippet.
- [Search Reddit and Quora from Claude via MCP](https://apify.com/johnvc/google-forums-search-api/examples/search-reddit-and-quora-from-claude-via-mcp?fpr=9n7kx3) - Reddit and Quora thread search inside [Claude](https://claude.ai/referral/uIlpa7nPLg) (free trial available) chat via MCP.

Last Updated: 2026.06.21

# Actor input Schema

## `q` (type: `string`):

Provide the search query for forum discussions (e.g. 'what is the best programming language', 'python vs java', 'best coffee brewing methods'). This field is required.

## `location` (type: `string`):

Set a geographic location string for localized forum results (e.g. 'Austin, TX, Texas, United States', 'New York, NY'). Optional. Helps narrow results to a specific area.

## `device` (type: `string`):

Choose the device type to emulate for the Google Forums search. Defaults to desktop.

## `gl` (type: `string`):

Set the country code for localization (ISO 3166-1 alpha-2, lowercase). Optional. Top 40 highest-traffic markets are exposed; for any other country, omit this field and pass the location string instead.

## `hl` (type: `string`):

Set the interface language code for localization (ISO 639-1 base codes, lowercase). Optional. The Actor normalizes regional variants like 'en-gb' to base codes like 'en'.

## `lr` (type: `string`):

Restrict results to a specific language (e.g. 'lang\_en', 'lang\_es', 'lang\_fr'). Optional. Different from the 'hl' interface language - this filters the result language itself.

## `safe` (type: `string`):

Toggle safe search to filter explicit content. Choose 'active' to filter explicit results, or 'off' to disable filtering. Optional, defaults to 'off'.

## `nfpr` (type: `string`):

Exclude results from auto-corrected queries when the original query is misspelled. Choose '0' to include auto-corrected results, '1' to exclude them. Optional, defaults to '0'.

## `filter` (type: `string`):

Toggle duplicate content filtering. Choose '0' to include duplicates, '1' to filter them out. Optional, defaults to '0'.

## `max_pages` (type: `integer`):

Set the maximum number of result pages to fetch. Use 0 for no limit (fetch all available pages). Default is 1. Each processed page is charged separately. Google Forums typically returns about 10 forum results per page.

## `output_file` (type: `string`):

Provide an optional filename to save the combined results JSON into the default key-value store. If omitted, a filename is generated from the query and timestamp.

## Actor input object example

```json
{
  "q": "what is the best programming language",
  "location": "Austin, TX, Texas, United States",
  "device": "desktop",
  "safe": "off",
  "nfpr": "0",
  "filter": "0",
  "max_pages": 1
}
```

# Actor output Schema

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

Open the default dataset to view or download all forum results.

# 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 = {
    "q": "what is the best programming language",
    "location": "Austin, TX, Texas, United States"
};

// Run the Actor and wait for it to finish
const run = await client.actor("johnvc/google-forums-search-api").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 = {
    "q": "what is the best programming language",
    "location": "Austin, TX, Texas, United States",
}

# Run the Actor and wait for it to finish
run = client.actor("johnvc/google-forums-search-api").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 '{
  "q": "what is the best programming language",
  "location": "Austin, TX, Texas, United States"
}' |
apify call johnvc/google-forums-search-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=johnvc/google-forums-search-api",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Forums API",
        "description": "Extract forum threads, Q&A, and community discussions from Google Search’s \"Forums\" tab. Supports 40+ countries, custom localization (GL/HL), and pagination. Get structured JSON data from Reddit, LinkedIn, Quora, and niche forums for sentiment analysis, market research, or AI training.",
        "version": "0.0",
        "x-build-id": "zmgGV9N6qrvKKw8s7"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/johnvc~google-forums-search-api/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-johnvc-google-forums-search-api",
                "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/johnvc~google-forums-search-api/runs": {
            "post": {
                "operationId": "runs-sync-johnvc-google-forums-search-api",
                "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/johnvc~google-forums-search-api/run-sync": {
            "post": {
                "operationId": "run-sync-johnvc-google-forums-search-api",
                "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": [
                    "q"
                ],
                "properties": {
                    "q": {
                        "title": "Search Query",
                        "minLength": 1,
                        "type": "string",
                        "description": "Provide the search query for forum discussions (e.g. 'what is the best programming language', 'python vs java', 'best coffee brewing methods'). This field is required."
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Set a geographic location string for localized forum results (e.g. 'Austin, TX, Texas, United States', 'New York, NY'). Optional. Helps narrow results to a specific area."
                    },
                    "device": {
                        "title": "Device",
                        "enum": [
                            "desktop",
                            "mobile",
                            "tablet"
                        ],
                        "type": "string",
                        "description": "Choose the device type to emulate for the Google Forums search. Defaults to desktop.",
                        "default": "desktop"
                    },
                    "gl": {
                        "title": "Country Code",
                        "enum": [
                            "us",
                            "gb",
                            "uk",
                            "ca",
                            "au",
                            "nz",
                            "ie",
                            "in",
                            "sg",
                            "hk",
                            "tw",
                            "de",
                            "fr",
                            "es",
                            "it",
                            "nl",
                            "be",
                            "ch",
                            "at",
                            "pt",
                            "se",
                            "no",
                            "dk",
                            "fi",
                            "pl",
                            "cz",
                            "gr",
                            "ro",
                            "hu",
                            "tr",
                            "ru",
                            "ua",
                            "br",
                            "mx",
                            "ar",
                            "cl",
                            "co",
                            "jp",
                            "kr",
                            "cn",
                            "th",
                            "vn",
                            "id",
                            "my",
                            "ph",
                            "ae",
                            "sa",
                            "il",
                            "eg",
                            "za",
                            "ng",
                            "ke"
                        ],
                        "type": "string",
                        "description": "Set the country code for localization (ISO 3166-1 alpha-2, lowercase). Optional. Top 40 highest-traffic markets are exposed; for any other country, omit this field and pass the location string instead."
                    },
                    "hl": {
                        "title": "Language Code",
                        "enum": [
                            "en",
                            "es",
                            "fr",
                            "de",
                            "it",
                            "pt",
                            "nl",
                            "ru",
                            "uk",
                            "pl",
                            "cs",
                            "sv",
                            "da",
                            "no",
                            "fi",
                            "el",
                            "tr",
                            "ar",
                            "he",
                            "ja",
                            "ko",
                            "zh",
                            "zh-cn",
                            "zh-tw",
                            "th",
                            "vi",
                            "id",
                            "ms",
                            "tl",
                            "hi",
                            "bn",
                            "ta",
                            "te",
                            "ur",
                            "fa",
                            "hu",
                            "ro",
                            "bg",
                            "hr",
                            "sk",
                            "sl"
                        ],
                        "type": "string",
                        "description": "Set the interface language code for localization (ISO 639-1 base codes, lowercase). Optional. The Actor normalizes regional variants like 'en-gb' to base codes like 'en'."
                    },
                    "lr": {
                        "title": "Language Restriction",
                        "type": "string",
                        "description": "Restrict results to a specific language (e.g. 'lang_en', 'lang_es', 'lang_fr'). Optional. Different from the 'hl' interface language - this filters the result language itself."
                    },
                    "safe": {
                        "title": "Safe Search",
                        "enum": [
                            "active",
                            "off"
                        ],
                        "type": "string",
                        "description": "Toggle safe search to filter explicit content. Choose 'active' to filter explicit results, or 'off' to disable filtering. Optional, defaults to 'off'.",
                        "default": "off"
                    },
                    "nfpr": {
                        "title": "Exclude Auto-corrected Results",
                        "enum": [
                            "0",
                            "1"
                        ],
                        "type": "string",
                        "description": "Exclude results from auto-corrected queries when the original query is misspelled. Choose '0' to include auto-corrected results, '1' to exclude them. Optional, defaults to '0'.",
                        "default": "0"
                    },
                    "filter": {
                        "title": "Filter Duplicates",
                        "enum": [
                            "0",
                            "1"
                        ],
                        "type": "string",
                        "description": "Toggle duplicate content filtering. Choose '0' to include duplicates, '1' to filter them out. Optional, defaults to '0'.",
                        "default": "0"
                    },
                    "max_pages": {
                        "title": "Maximum Pages",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Set the maximum number of result pages to fetch. Use 0 for no limit (fetch all available pages). Default is 1. Each processed page is charged separately. Google Forums typically returns about 10 forum results per page.",
                        "default": 1
                    },
                    "output_file": {
                        "title": "Output File",
                        "type": "string",
                        "description": "Provide an optional filename to save the combined results JSON into the default key-value store. If omitted, a filename is generated from the query and timestamp."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
