# 🧵 Threads Search Post Scraper (`scrapier/threads-search-post-scraper`) Actor

🧵  Threads Search Post Scraper pulls posts, replies & metadata from Threads by keyword, hashtag or profile. Get text, author, timestamps, metrics, media & links. 🔎 Perfect for social listening, competitor analysis, research & reporting. 🚀 Fast, reliable, export-ready.

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

## Pricing

from $5.99 / 1,000 results

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

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

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

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

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

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

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

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

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

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

### 🧵 Threads Search Post Scraper

🧵 Threads Search Post Scraper collects public Threads post data and replies by resolving a post from a URL, numeric ID, or search phrase, then fetching the replies connection and outputting flat, normalized post objects. It solves the challenge of turning Threads search results and post pages into clean, structured data for social listening, competitor monitoring, and reporting. Built for marketers, developers, analysts, and researchers, this Meta Threads scraper scales from quick lookups to automated pipelines with consistent fields that are export-ready.

### What data / output can you get?

Below are examples of the normalized fields pushed to your Apify dataset. Values are illustrative and reflect the actual keys produced by the actor.

| Data field | Description | Example value |
| --- | --- | --- |
| post_url | Resolved Threads permalink constructed from username and code | https://www.threads.com/@zuck/post/AbCdEfGhIjK |
| pk | Post primary key (numeric string) | "123456789012345" |
| code | Post code used in the permalink | "AbCdEfGhIjK" |
| caption | Post text or caption payload | {"text":"Excited to share what’s next…"} |
| like_count | Number of likes (if present) | 1523 |
| taken_at | Unix timestamp of the post | 1714156800 |
| user | Normalized author object (ordered fields incl. username, is_verified, etc.) | {"username":"zuck","is_verified":true,...} |
| text_post_app_info | Threads-specific metadata incl. share_info and text_fragments | {"share_info":{"can_quote_post":true,...},"text_fragments":{"fragments":[...]}} |
| media_type | Media type indicator | 1 |
| image_versions2 | Image versions payload (if present) | {"candidates":[...]} |
| video_versions | Video versions payload (if present) | [{"type":101,"url":"..."}] |
| sharing_friction_info | Defaulted when absent; sharing friction metadata | {"should_have_sharing_friction":false,"sharing_friction_payload":null} |

Bonus fields include canonical_url, original_height, original_width, usertags, audio, carousel_media, gen_ai_detection_method, and more — all kept in a flat, analysis-ready structure. You can download your dataset from Apify in formats like JSON, CSV, or Excel for downstream use.

### Key features

- 🔎 Public GraphQL discovery & resolution  
  Loads Threads GraphQL credentials from the public search page, resolves each target post via URL, numeric ID, or search phrase, and fetches the replies connection for the chosen thread.

- 🧱 Flat, normalized posts  
  Outputs flat post objects with a consistent field order and helpful defaults (e.g., gen_ai_detection_method, sharing_friction_info), ideal for analysis and export. Great as a Threads search results scraper or Threads keyword search scraper.

- 🧪 No login required  
  Works without credentials by using public search and endpoints, making it a safe choice when you need a Meta Threads scraper without account risk.

- 🌐 Tiered proxy escalation for reliability  
  Smart connectivity flow: start with no proxy → try SHADER (datacenter) → escalate and remain on RESIDENTIAL with up to 3 retries and fresh sessions. Perfect for higher-sensitivity loads.

- 📥 Batch-friendly inputs  
  Accepts a list of targets where each line can be a full Threads post URL, a numeric post ID (10+ digits), or a search phrase — handy for scheduling or bulk research.

- 💻 Developer-ready  
  Built on Apify with Python and aiohttp under the hood. Clean JSON output fits data pipelines, and it’s easy to integrate with Python or automation tools. Ideal for a Threads Python scraper workflow.

- 🔌 Workflow integration  
  Use as a Threads search post scraper in automation stacks (e.g., n8n, Make, Zapier) to trigger downstream alerts, dashboards, or enrichment jobs.

- 🛠 Production reliability  
  Robust error handling, sensible defaults, and consistent output schema make it a dependable Threads data extractor for repeated runs.

### How to use 🧵 Threads Search Post Scraper - step by step

1. Create or log in to your Apify account.
2. Open the 🧵 Threads Search Post Scraper actor.
3. In “Targets to collect” (urls), enter one item per line:
   - Full post URL: https://www.threads.com/@username/post/AbCdEfGhIjK
   - Numeric post ID: 10+ digit string like 123456789012345
   - Search phrase: e.g., Mark Zuckerberg (the first thread from that search’s HTML is used to fetch replies)
4. (Optional) Configure “Proxy (optional)” if you need extra reliability. If not provided, the run starts without a proxy and escalates as needed.
5. Click Start. The actor will:
   - Discover GraphQL credentials from the public search page
   - Resolve each target into a post ID
   - Fetch the replies connection and normalize posts
6. Monitor the run logs for progress. You’ll see messages for discovery, resolution, download, parsed items, and saved rows.
7. Download results from the run’s Dataset — export to JSON, CSV, or Excel for analysis or reporting.

Pro tip: Use search phrases to Scrape Threads search results quickly, then schedule the actor to track replies over time and feed the JSON into your analytics or CRM.

### Use cases

| Use case | Description |
| --- | --- |
| Social listening & trend tracking | Monitor keyword-driven Threads conversations and capture replies for context-rich insights. |
| Competitor post monitoring | Collect replies and engagement metrics from competitor posts to benchmark content performance. |
| Campaign performance review | Export flat post and reply data to analyze like_count trends and audience reactions. |
| Academic & media research | Build structured datasets from public Threads search phrases for longitudinal analysis. |
| Reporting & dashboards | Pipe outputs into BI tools to visualize thread activity over time. |
| Automation pipelines (API) | Trigger a Threads posts scraper workflow that resolves posts from search and pushes JSON into downstream systems. |
| Brand monitoring by keywords | Use as a Threads keyword search scraper to detect conversations mentioning your brand. |
| Hashtag discovery workflows | Treat hashtags as search phrases to quickly collect the first thread and its replies. |

### Why choose 🧵 Threads Search Post Scraper?

This tool prioritizes precision, automation, and reliability for scraping Threads posts and replies at scale.

- 🎯 Accurate, normalized output: Flat post objects with consistent fields and sensible defaults.
- 🌍 No-login approach: Uses public discovery and endpoints without requiring accounts or cookies.
- 📈 Scales to batch runs: Handle multiple URLs, IDs, or search phrases in one go.
- 💻 Developer access: Clean JSON suitable for APIs, Python scripts, and data pipelines.
- 🔐 Safe & public: Operates on publicly available data discovered via the Threads search page.
- 💸 Cost-effective reliability: Tiered proxy strategy for robust execution when targets get busy.
- 🔗 Integrations-ready: Fits automation stacks and export workflows without additional cleanup.

Unlike unstable browser extensions, this Threads posts scraper delivers structured, repeatable results and robust connectivity through a smart proxy escalation strategy.

### Is it legal / ethical to use 🧵 Threads Search Post Scraper?

Yes — when used responsibly. The actor discovers credentials from the public Threads search page and fetches public data for the specified targets. It does not access private or authenticated data.

Guidelines for compliant use:
- Scrape only publicly available content.
- Avoid collecting or processing personal data beyond what’s publicly visible.
- Follow applicable regulations (e.g., GDPR, CCPA) and Terms of Service.
- Work with your legal team for edge cases or commercial deployments.

### Input parameters & output format

#### Example JSON input
```json
{
  "urls": [
    "Mark Zuckerberg",
    "https://www.threads.com/@zuck/post/AbCdEfGhIjK",
    "123456789012345"
    ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
````

- urls (array, required):\
  Description: Each line can be a full post URL (threads.com or threads.net), a numeric post ID (10+ digits), or a search phrase. Phrases behave like the script’s search query: the first thread from that search’s HTML is used to fetch replies.\
  Default: not set (UI prefill: \["Mark Zuckerberg"]).

- proxyConfiguration (object, optional):\
  Description: Leave off for a simple run. Turn on Apify Proxy to route requests through Apify’s network — useful on busy or sensitive targets.\
  Default: not set (UI prefill: {"useApifyProxy": false}).

#### Example JSON output

Each item in the dataset is a flat post object. Below is a representative example with real field names from the actor:

```json
{
  "post_url": "https://www.threads.com/@zuck/post/AbCdEfGhIjK",
  "pk": "123456789012345",
  "user": {
    "friendship_status": {
      "muting": false,
      "following": false,
      "followed_by": false,
      "outgoing_request": null,
      "blocking": null
    },
    "id": "9876543210",
    "pk": "9876543210",
    "text_app_last_visited_time": 0,
    "profile_pic_url": "https://example.com/pic.jpg",
    "username": "zuck",
    "full_name": "Mark Zuckerberg",
    "transparency_label": null,
    "transparency_product": null,
    "transparency_product_enabled": null,
    "is_verified": true,
    "text_post_app_is_private": null,
    "has_onboarded_to_text_post_app": null
  },
  "text_post_app_info": {
    "is_post_unavailable": false,
    "pinned_post_info": null,
    "id": "123456789012345",
    "share_info": {
      "reposted_post": null,
      "is_reposted_by_viewer": false,
      "can_quote_post": true,
      "quoted_attachment_author_attribution_allowed": true,
      "quoted_attachment_post_unavailable": false,
      "quoted_attachment_post": null,
      "quoted_post": null
    },
    "show_header_follow": null,
    "self_thread_info": null,
    "is_spoiler_media": null,
    "is_markup": null,
    "special_effects_enabled_str": null,
    "reply_control": null,
    "can_reply": null,
    "can_private_reply": null,
    "is_ghost_post": null,
    "tag_header": null,
    "direct_reply_count": null,
    "ghost_post_exp_time_ms": null,
    "ghost_post_approximate_like_count_str": null,
    "ghost_post_approximate_reply_count_str": null,
    "ghost_post_reply_type": null,
    "repost_count": null,
    "quote_count": null,
    "reshare_count": null,
    "text_fragments": {
      "fragments": []
    },
    "custom_feed_preview_info": null,
    "platform_podcast_episode_info": null,
    "platform_podcast_info": null,
    "link_preview_attachment": null,
    "link_preview_response": null,
    "linked_inline_media": null,
    "snippet_attachment_info": null,
    "algo_tweaks_info": null,
    "is_reply": null,
    "reply_to_author": null,
    "reply_approval_info": null,
    "hush_info": null,
    "system_status_message": null,
    "private_reply_partner": null,
    "fediverse_info": {
      "is_federated": false,
      "enqueued_for_federation": null,
      "federated_like_count": null
    },
    "self_thread_count": null,
    "root_post_author": null,
    "is_liked_by_root_author": null,
    "related_trends_info": null,
    "post_unavailable_reason": null,
    "post_tombstone_info": null
  },
  "id": "123456789012345",
  "logging_info_token": null,
  "is_paid_partnership": null,
  "audio": null,
  "caption": {
    "text": "Excited to share what’s next…"
  },
  "caption_is_edited": null,
  "transcription_data": null,
  "carousel_media": null,
  "code": "AbCdEfGhIjK",
  "image_versions2": null,
  "original_height": 1080,
  "original_width": 1080,
  "accessibility_caption": null,
  "usertags": null,
  "video_versions": null,
  "has_audio": null,
  "media_type": 1,
  "caption_add_on": null,
  "has_liked": false,
  "like_count": 1523,
  "taken_at": 1714156800,
  "media_overlay_info": null,
  "sharing_friction_info": {
    "should_have_sharing_friction": false,
    "sharing_friction_payload": null
  },
  "canonical_url": "https://www.threads.com/@zuck/post/AbCdEfGhIjK",
  "giphy_media_info": null,
  "metaPlace": null,
  "meta_place": null,
  "gen_ai_detection_method": {
    "detection_method": "NONE"
  },
  "organic_tracking_token": null,
  "__token": null,
  "like_and_view_counts_disabled": null
}
```

Notes:

- All fields above come directly from the actor’s normalized post objects.
- Some fields may be null depending on the post (e.g., video\_versions, audio, usertags).
- The actor saves one dataset item per post in the thread (root + replies), making it a precise Threads replies scraper and Threads post downloader for public data.

### FAQ

#### Do I need to log in to use this Threads scraper?

No. The actor discovers credentials from the public Threads search page and fetches public data without login or cookies. It works as a Meta Threads scraper that relies on public endpoints.

#### Can I scrape by keyword or search phrase?

Yes. You can input a search phrase in urls, and the actor will resolve the first thread from that search’s HTML to fetch replies. This makes it useful as a Threads keyword search scraper and Threads search results scraper.

#### Does it support post URLs and numeric IDs?

Yes. Provide full post URLs (threads.com or threads.net) or a numeric post ID (10+ digits). The actor will resolve the post and download its replies.

#### How reliable is it on busy targets?

Very reliable. It starts with no proxy, escalates to SHADER (datacenter), and then switches to RESIDENTIAL (staying there) with up to 3 retries using fresh sessions. This tiered proxy strategy improves success rates on sensitive runs.

#### What exactly gets exported?

Flat post objects with fields like post\_url, pk, user, caption, like\_count, taken\_at, media fields, and more. You can download the dataset and export to JSON, CSV, or Excel for analysis.

#### Can I integrate this with Python or APIs?

Yes. Results land in an Apify dataset as JSON, which you can fetch via Apify API or consume in your Threads Python scraper pipelines and automation workflows.

#### Is hashtag search supported?

You can treat hashtags as search phrases in urls. The actor resolves the first thread from that search page and collects replies, making it a practical Threads hashtag search scraper for public results.

#### Is it legal to scrape Threads with this?

Yes, when used responsibly. The actor accesses public data only. Always comply with applicable laws and Terms of Service, and consult your legal team for specific use cases.

### Final thoughts

🧵 Threads Search Post Scraper is built to turn public Threads posts and replies into clean, flat JSON for analysis and automation. With public discovery, structured outputs, and a robust proxy strategy, it’s ideal for marketers, developers, analysts, and researchers who need to Scrape Threads posts at scale. Pull results into your data stack via API or Python, automate keyword-based monitoring, and start extracting smarter insights from Threads today.

# Actor input Schema

## `urls` (type: `array`):

Each line: a full post URL (threads.com or threads.net), a numeric post ID (10+ digits), or a search phrase. Phrases behave like the standalone script’s search query: the first thread from that search’s HTML is used to fetch replies. Example URL: https://www.threads.com/@zuck/post/AbCdEfGhIjK — example phrase: Mark Zuckerberg

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

Leave off for a simple run. Turn on Apify Proxy here when you want Apify to route requests through its network — useful on busy or sensitive targets.

## Actor input object example

```json
{
  "urls": [
    "Mark Zuckerberg"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# 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 = {
    "urls": [
        "Mark Zuckerberg"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapier/threads-search-post-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 = {
    "urls": ["Mark Zuckerberg"],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapier/threads-search-post-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 '{
  "urls": [
    "Mark Zuckerberg"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call scrapier/threads-search-post-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "🧵 Threads Search Post Scraper",
        "description": "🧵  Threads Search Post Scraper pulls posts, replies & metadata from Threads by keyword, hashtag or profile. Get text, author, timestamps, metrics, media & links. 🔎 Perfect for social listening, competitor analysis, research & reporting. 🚀 Fast, reliable, export-ready.",
        "version": "1.0",
        "x-build-id": "M5juAfv2Yo8ct6TRE"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapier~threads-search-post-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapier-threads-search-post-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/scrapier~threads-search-post-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapier-threads-search-post-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/scrapier~threads-search-post-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapier-threads-search-post-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": [
                    "urls"
                ],
                "properties": {
                    "urls": {
                        "title": "🔗 Targets to collect",
                        "type": "array",
                        "description": "Each line: a full post URL (threads.com or threads.net), a numeric post ID (10+ digits), or a search phrase. Phrases behave like the standalone script’s search query: the first thread from that search’s HTML is used to fetch replies. Example URL: https://www.threads.com/@zuck/post/AbCdEfGhIjK — example phrase: Mark Zuckerberg",
                        "items": {
                            "type": "string"
                        }
                    },
                    "proxyConfiguration": {
                        "title": "🌐 Proxy (optional)",
                        "type": "object",
                        "description": "Leave off for a simple run. Turn on Apify Proxy here when you want Apify to route requests through its network — useful on busy or sensitive targets."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
