# Mastodon $1💰 URL, Trend & Profile Scraper (`abotapi/mastodon-social-scraper`) Actor

From $1/1K. Scrape trending Mastodon profiles and related posts from any instance’s public API. Returns rich profile data, follower counts, bios, avatars, fields, and thread replies. Supports nested profile reviews or flat review output.

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

## Pricing

from $1.00 / 1,000 results

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## Mastodon Explore Scraper

Pull the trending profiles and their content from any Mastodon instance's explore page, straight from the public Mastodon API. You get rich profile records (bio, follower counts, fields, avatar) and their reviews, where a review is a post or a reply in its thread. Choose between profiles with reviews nested inside, a flat stream of reviews, or bulk posts by keyword. Defaults to mastodon.social and works on any Mastodon server.

### Why this scraper

- Three output modes: trending profiles with nested reviews, reviews only (one flat record each), or keyword posts in bulk.
- Keyword mode harvests posts by topic at volume: each keyword timeline is walked back via load-more pagination up to your post cap (tens of thousands of posts).
- Reviews cover both a profile's own posts and the replies underneath them, so you capture the full conversation.
- Deep history: pull up to thousands of a profile's past posts, walked automatically via load-more pagination.
- Reads the public Mastodon REST API directly: fast, stable JSON, no fragile page parsing.
- Trending profiles merge two signals: authors of currently trending posts and the active public directory.
- URL mode: paste profile or post links to scrape exactly what you want.
- Works on any instance (mastodon.social, mas.to, fosstodon.org, your own server).
- Every record keeps the full upstream account object, so no field is ever dropped.

### Data you get

Profile record (profiles mode):

| Field | Example |
| --- | --- |
| recordType | profile |
| id | 13179 |
| acct | Mastodon |
| username | Mastodon |
| displayName | Mastodon |
| bio | Free, open-source decentralized social media. Not for sale. |
| followersCount | 853000 |
| followingCount | 4 |
| statusesCount | 700 |
| url | https://mastodon.social/@Mastodon |
| avatar | https://files.mastodon.social/accounts/avatars/000/013/179/original/...png |
| bot | false |
| createdAt | 2016-11-23T00:00:00.000Z |
| fields | [{"name": "Homepage", "value": "joinmastodon.org"}] |
| reviewCount | 5 |
| reviews | [ ... array of review records ... ] |

Review record (reviews mode, keyword mode, or nested under a profile):

| Field | Example |
| --- | --- |
| recordType | review |
| id | 109876543210987654 |
| reviewType | post (or reply) |
| isReblog | false |
| rebloggedByAcct | null (set to the booster's handle when isReblog is true) |
| sourceKeyword | news (keyword mode only; null otherwise) |
| contentText | We just shipped a new version with quote posts. |
| createdAt | 2026-05-20T14:03:11.000Z |
| language | en |
| url | https://mastodon.social/@Mastodon/109876543210987654 |
| repliesCount | 42 |
| reblogsCount | 318 |
| favouritesCount | 901 |
| inReplyToId | null |
| tags | ["mastodon", "fediverse"] |
| authorAcct | Mastodon |
| authorDisplayName | Mastodon |
| account | { ... full upstream account object ... } |

### How to use

Trending profiles with their reviews (default):

```json
{
  "mode": "profiles",
  "instanceUrl": "https://mastodon.social",
  "profileSource": "both",
  "includeReplies": true,
  "maxProfiles": 10,
  "maxReviewsPerProfile": 5,
  "maxRepliesPerPost": 10
}
````

Reviews only, capped at 200, no replies (faster and cheaper):

```json
{
  "mode": "reviews",
  "profileSource": "trending",
  "includeReplies": false,
  "maxProfiles": 20,
  "maxReviewsPerProfile": 10,
  "maxReviews": 200
}
```

Bulk posts by keyword (high volume, load-more pagination):

```json
{
  "mode": "keyword",
  "keywords": ["news", "art", "climate"],
  "includeReplies": false,
  "maxPosts": 5000
}
```

Deep history of one profile (thousands of past posts):

```json
{
  "mode": "reviews",
  "urls": ["https://mastodon.social/@Mastodon"],
  "includeReplies": false,
  "maxReviewsPerProfile": 2000
}
```

Active local directory profiles only:

```json
{
  "mode": "profiles",
  "profileSource": "directory",
  "onlyLocal": true,
  "maxProfiles": 25
}
```

URL mode (specific profiles and posts):

```json
{
  "mode": "reviews",
  "urls": [
    "https://mastodon.social/@Mastodon",
    "https://mastodon.social/@Gargron",
    "https://mastodon.social/@Mastodon/109876543210987654"
  ],
  "includeReplies": true
}
```

### Input parameters

| Parameter | Type | Default | Description |
| --- | --- | --- | --- |
| mode | string | profiles | profiles (nested reviews), reviews (flat), or keyword (bulk posts by topic) |
| instanceUrl | string | https://mastodon.social | Any public Mastodon server |
| profileSource | string | both | trending, directory, or both (used when no URLs) |
| onlyLocal | boolean | false | Directory: local accounts only |
| urls | array | \[] | Profile or post URLs; when set, overrides explore/profiles/reviews/keyword |
| keywords | array | \[news] | Keywords to bulk-scrape in keyword mode (matched as tags, with or without #) |
| includeReplies | boolean | true | Fetch the reply thread under each post |
| maxProfiles | integer | 10 | Max profiles to scrape (up to 500) |
| maxReviewsPerProfile | integer | 5 | Posts to fetch per profile, walked via load-more (up to 5000) |
| maxRepliesPerPost | integer | 10 | Replies to keep per post |
| maxReviews | integer | 0 | Reviews-mode total cap (0 = unlimited) |
| maxPosts | integer | 500 | Keyword-mode total cap, split across keywords (up to 100000) |
| proxy | object | Apify datacenter | Proxy configuration |

### Output example

```json
{
  "recordType": "profile",
  "id": "13179",
  "acct": "Mastodon",
  "username": "Mastodon",
  "displayName": "Mastodon",
  "bio": "Free, open-source decentralized social media. Not for sale.",
  "followersCount": 853000,
  "followingCount": 4,
  "statusesCount": 700,
  "url": "https://mastodon.social/@Mastodon",
  "bot": false,
  "createdAt": "2016-11-23T00:00:00.000Z",
  "fields": [{ "name": "Homepage", "value": "joinmastodon.org" }],
  "reviewCount": 2,
  "reviews": [
    {
      "recordType": "review",
      "id": "109876543210987654",
      "reviewType": "post",
      "contentText": "We just shipped a new version with quote posts.",
      "createdAt": "2026-05-20T14:03:11.000Z",
      "repliesCount": 42,
      "reblogsCount": 318,
      "favouritesCount": 901,
      "url": "https://mastodon.social/@Mastodon/109876543210987654",
      "authorAcct": "Mastodon"
    },
    {
      "recordType": "review",
      "id": "109876543299990000",
      "reviewType": "reply",
      "contentText": "Congrats, this is huge for the fediverse!",
      "createdAt": "2026-05-20T14:09:55.000Z",
      "inReplyToId": "109876543210987654",
      "authorAcct": "someuser"
    }
  ]
}
```

### Plan requirement

Runs on any Apify plan, including the free tier. The Mastodon API is public, so Apify Datacenter proxy (the default) is sufficient. For very large jobs, datacenter proxy rotation helps keep the run under each server's per-IP rate limit; residential proxy is optional and not required.

# Actor input Schema

## `mode` (type: `string`):

What the actor returns. 'profiles' = one record per trending profile with its reviews nested inside. 'reviews' = one flat record per review (a post or a reply). 'keyword' = bulk posts for the keywords you list, one flat record per post, walked via load-more pagination (the high-volume option).

## `instanceUrl` (type: `string`):

Which Mastodon server to read the explore page from. Defaults to mastodon.social. Any public Mastodon instance works (for example https://mas.to or https://fosstodon.org).

## `profileSource` (type: `string`):

Where trending profiles come from. 'trending' = the authors of currently trending posts. 'directory' = the active public profile directory. 'both' = the two merged and deduped. Only applies when no URLs are provided.

## `onlyLocal` (type: `boolean`):

When using the directory source, return only accounts that are local to the chosen instance (skip federated accounts from other servers).

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

Optional. Paste Mastodon profile URLs (https://mastodon.social/@username) or post URLs (https://mastodon.social/@username/123456789). When provided, the explore search is skipped and the actor scrapes exactly these instead. Leave empty to use profiles, reviews, or keyword mode. Multiple URLs supported.

## `keywords` (type: `array`):

Topics to bulk-scrape when mode is 'keyword'. Enter one word per entry, with or without a leading # (for example: news, art, climate). Each keyword is matched as a Mastodon tag and its public timeline is walked back via load-more pagination up to Max posts. Note: keywords match single tags, not free-text phrases (free-text search needs a token).

## `includeReplies` (type: `boolean`):

Fetch the reply thread under each post. Replies are added as reviews of type 'reply'. Turning this off makes runs faster and cheaper (one fewer request per post).

## `maxProfiles` (type: `integer`):

Maximum number of trending profiles to scrape (profiles mode, or as review sources in reviews mode).

## `maxReviewsPerProfile` (type: `integer`):

How many of each profile's most recent posts to fetch. The profile timeline is walked back via load-more pagination, so you can pull deep history (up to 5000). Each post may also bring its replies (see Include replies).

## `maxRepliesPerPost` (type: `integer`):

Cap on how many replies to keep per post when Include replies is on.

## `maxReviews` (type: `integer`):

Hard cap on total reviews returned in reviews mode. 0 means unlimited (bounded by the profile and per-post limits above).

## `maxPosts` (type: `integer`):

Hard cap on total posts returned in keyword mode, split evenly across the keywords you list. Each keyword timeline is walked via load-more until this many posts are collected.

## `proxy` (type: `object`):

Proxy settings. The Mastodon API is public, so Apify Datacenter proxy (the default) is enough. Datacenter also rotates exit IPs, which keeps runs under the per-IP rate limit on large jobs.

## Actor input object example

```json
{
  "mode": "profiles",
  "instanceUrl": "https://mastodon.social",
  "profileSource": "both",
  "onlyLocal": false,
  "urls": [],
  "keywords": [
    "news"
  ],
  "includeReplies": true,
  "maxProfiles": 10,
  "maxReviewsPerProfile": 5,
  "maxRepliesPerPost": 10,
  "maxReviews": 0,
  "maxPosts": 500,
  "proxy": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "mode": "profiles",
    "instanceUrl": "https://mastodon.social",
    "profileSource": "both",
    "urls": [],
    "keywords": [
        "news"
    ],
    "maxProfiles": 10,
    "maxReviewsPerProfile": 5,
    "maxRepliesPerPost": 10,
    "maxPosts": 500,
    "proxy": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("abotapi/mastodon-social-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 = {
    "mode": "profiles",
    "instanceUrl": "https://mastodon.social",
    "profileSource": "both",
    "urls": [],
    "keywords": ["news"],
    "maxProfiles": 10,
    "maxReviewsPerProfile": 5,
    "maxRepliesPerPost": 10,
    "maxPosts": 500,
    "proxy": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("abotapi/mastodon-social-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 '{
  "mode": "profiles",
  "instanceUrl": "https://mastodon.social",
  "profileSource": "both",
  "urls": [],
  "keywords": [
    "news"
  ],
  "maxProfiles": 10,
  "maxReviewsPerProfile": 5,
  "maxRepliesPerPost": 10,
  "maxPosts": 500,
  "proxy": {
    "useApifyProxy": true
  }
}' |
apify call abotapi/mastodon-social-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Mastodon $1💰 URL, Trend & Profile Scraper",
        "description": "From $1/1K. Scrape trending Mastodon profiles and related posts from any instance’s public API. Returns rich profile data, follower counts, bios, avatars, fields, and thread replies. Supports nested profile reviews or flat review output.",
        "version": "1.0",
        "x-build-id": "BtUJEkSQUskmW273e"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/abotapi~mastodon-social-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-abotapi-mastodon-social-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/abotapi~mastodon-social-scraper/runs": {
            "post": {
                "operationId": "runs-sync-abotapi-mastodon-social-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/abotapi~mastodon-social-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-abotapi-mastodon-social-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": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Output mode",
                        "enum": [
                            "profiles",
                            "reviews",
                            "keyword"
                        ],
                        "type": "string",
                        "description": "What the actor returns. 'profiles' = one record per trending profile with its reviews nested inside. 'reviews' = one flat record per review (a post or a reply). 'keyword' = bulk posts for the keywords you list, one flat record per post, walked via load-more pagination (the high-volume option).",
                        "default": "profiles"
                    },
                    "instanceUrl": {
                        "title": "Mastodon instance",
                        "type": "string",
                        "description": "Which Mastodon server to read the explore page from. Defaults to mastodon.social. Any public Mastodon instance works (for example https://mas.to or https://fosstodon.org).",
                        "default": "https://mastodon.social"
                    },
                    "profileSource": {
                        "title": "Trending profile source",
                        "enum": [
                            "trending",
                            "directory",
                            "both"
                        ],
                        "type": "string",
                        "description": "Where trending profiles come from. 'trending' = the authors of currently trending posts. 'directory' = the active public profile directory. 'both' = the two merged and deduped. Only applies when no URLs are provided.",
                        "default": "both"
                    },
                    "onlyLocal": {
                        "title": "Local accounts only",
                        "type": "boolean",
                        "description": "When using the directory source, return only accounts that are local to the chosen instance (skip federated accounts from other servers).",
                        "default": false
                    },
                    "urls": {
                        "title": "Profile or post URLs (optional)",
                        "type": "array",
                        "description": "Optional. Paste Mastodon profile URLs (https://mastodon.social/@username) or post URLs (https://mastodon.social/@username/123456789). When provided, the explore search is skipped and the actor scrapes exactly these instead. Leave empty to use profiles, reviews, or keyword mode. Multiple URLs supported.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "keywords": {
                        "title": "Keywords (keyword mode)",
                        "type": "array",
                        "description": "Topics to bulk-scrape when mode is 'keyword'. Enter one word per entry, with or without a leading # (for example: news, art, climate). Each keyword is matched as a Mastodon tag and its public timeline is walked back via load-more pagination up to Max posts. Note: keywords match single tags, not free-text phrases (free-text search needs a token).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "includeReplies": {
                        "title": "Include replies",
                        "type": "boolean",
                        "description": "Fetch the reply thread under each post. Replies are added as reviews of type 'reply'. Turning this off makes runs faster and cheaper (one fewer request per post).",
                        "default": true
                    },
                    "maxProfiles": {
                        "title": "Max profiles",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of trending profiles to scrape (profiles mode, or as review sources in reviews mode).",
                        "default": 10
                    },
                    "maxReviewsPerProfile": {
                        "title": "Max posts per profile",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "How many of each profile's most recent posts to fetch. The profile timeline is walked back via load-more pagination, so you can pull deep history (up to 5000). Each post may also bring its replies (see Include replies).",
                        "default": 5
                    },
                    "maxRepliesPerPost": {
                        "title": "Max replies per post",
                        "minimum": 0,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Cap on how many replies to keep per post when Include replies is on.",
                        "default": 10
                    },
                    "maxReviews": {
                        "title": "Max reviews (reviews mode)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Hard cap on total reviews returned in reviews mode. 0 means unlimited (bounded by the profile and per-post limits above).",
                        "default": 0
                    },
                    "maxPosts": {
                        "title": "Max posts (keyword mode)",
                        "minimum": 1,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Hard cap on total posts returned in keyword mode, split evenly across the keywords you list. Each keyword timeline is walked via load-more until this many posts are collected.",
                        "default": 500
                    },
                    "proxy": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy settings. The Mastodon API is public, so Apify Datacenter proxy (the default) is enough. Datacenter also rotates exit IPs, which keeps runs under the per-IP rate limit on large jobs.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
