# SOCIAL MEDIA Scraper - Posts, Hashtags, Accounts & Trends (`claudethegoat/mastodon-social-scraper`) Actor

Scrape Mastodon (any instance) via the official public REST API: hashtag timelines, account posts + profiles, trending statuses/tags/links, and account/hashtag search. No credentials, no proxy required.

- **URL**: https://apify.com/claudethegoat/mastodon-social-scraper.md
- **Developed by:** [Manik Anand](https://apify.com/claudethegoat) (community)
- **Categories:** Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$3.00 / 1,000 result scrapeds

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

## Mastodon Scraper — Posts, Hashtags, Accounts & Trends (No Login)

**Export Mastodon posts, profiles, hashtags and trends to JSON, CSV or Excel — no account, no API key, no proxy.** Point it at `mastodon.social` (the default) or *any* Mastodon instance in the fediverse and pull clean, structured data in one run. Built on each instance's official public REST API, so there is nothing to bypass and nothing to break.

Mastodon is the largest open, decentralized social network — a fast-growing, ad-free source of real public discourse. This scraper turns it into a dataset you can actually use for social listening, brand monitoring, research and AI/RAG pipelines.

### What you can scrape

- **Hashtag timeline** — every recent public post for any `#tag`, deep-paginated, with an optional *media-only* filter. Great for topic tracking and social listening.
- **Account** — any user's full **profile** *plus* their posts, with reply/boost filters. Follower counts, bio, join date, post history.
- **Trends** — what's trending on the instance **right now**: trending statuses, hashtags, or news links, with usage stats.
- **Search** — find **accounts** or **hashtags** by keyword (up to 40 matches per term, keyless).

Everything lands in **one unified dataset** with consistent field names and both **raw HTML** and **clean plain-text** bodies — ready for a spreadsheet, a database, or an LLM.

### Why this actor

| Option | The catch | This actor |
|---|---|---|
| Other Mastodon scrapers on the Store | Single mode (hashtags **or** accounts), single-instance assumptions, or monthly subscriptions | Hashtag **+** account **+** trends **+** search, **any instance**, **pay only per result** |
| The raw Mastodon API | You maintain pagination, HTML stripping, rate-limit backoff and retries yourself | One JSON input, clean flat schema, it handles the messy parts |
| Login-based scrapers | Need credentials / risk your account | **100% keyless** — only public data, nothing to get banned |

- **Never crashes on you.** Every network call retries transient errors (429 rate-limits, 5xx, timeouts) with backoff and degrades gracefully on hard errors — a bad hashtag or an unreachable instance is skipped, the run still finishes and delivers everything it gathered.
- **Zero proxy cost.** Official public API, no anti-bot bypass, no residential proxies to pay for.
- **Federation-aware.** Not limited to one server — scrape `mastodon.social`, `fosstodon.org`, `hachyderm.io`, or any instance.

### Common use cases

- **Brand & competitor monitoring** — track a `#brand` hashtag or a competitor's account across the fediverse; watch mentions, sentiment inputs and engagement.
- **Social listening** — follow a topic (`#ai`, `#climate`, `#elections`) with scheduled daily pulls into a dashboard.
- **AI / RAG pipelines** — feed fresh, open, public discourse into retrieval and fine-tuning without platform lock-in or login walls.
- **Trend monitoring** — daily snapshots of trending statuses/tags/links for a newsletter or analytics feed.
- **Academic & network research** — collect public posts and account metadata at scale for computational social science.

### Input examples

Recent posts for two hashtags:

```json
{
  "mode": "hashtag",
  "instance": "mastodon.social",
  "searchTerms": ["ai", "opensource"],
  "maxResultsPerTerm": 500
}
````

A user's profile + original posts (no replies, no boosts):

```json
{
  "mode": "account",
  "instance": "mastodon.social",
  "accounts": ["Gargron"],
  "excludeReplies": true,
  "excludeReblogs": true,
  "maxResultsPerTerm": 200
}
```

What's trending right now:

```json
{ "mode": "trends", "trendType": "statuses", "maxResultsPerTerm": 40 }
```

Find accounts by keyword:

```json
{ "mode": "search", "searchType": "accounts", "searchTerms": ["journalism", "python"] }
```

### Output

One row per result, tagged by `type`. Load it as JSON, CSV, or Excel from the dataset.

**Statuses** (`type: "status"`): `id`, `url`, `uri`, `created_at`, `edited_at`, `language`, `visibility`, `text` (plain), `content_html`, `spoiler_text`, `sensitive`, `is_reblog`, `in_reply_to_id`, `replies_count`, `reblogs_count`, `favourites_count`, `author_id`, `author_acct`, `author_username`, `author_display_name`, `author_url`, `author_followers`, `tags[]`, `media_count`, `media_urls[]`, `card_url`

**Accounts** (`type: "account"`): `id`, `acct`, `username`, `url`, `display_name`, `note` (plain), `note_html`, `created_at`, `last_status_at`, `bot`, `locked`, `discoverable`, `followers_count`, `following_count`, `statuses_count`, `avatar_url`, `header_url`, `fields[]`

**Tags** (`type: "tag"`): `name`, `url`, `total_uses`, `total_accounts`, `history[]`

**Links** (`type: "link"`): `url`, `title`, `description`, `provider_name`, `author_name`, `published_at`, `image`, `total_uses`, `total_accounts`, `history[]`

Example status row:

```json
{
  "type": "status",
  "id": "116906215486227555",
  "url": "https://www.npr.org/2026/07/12/nx-s1-5867763/ai-artificial-intelligence",
  "created_at": "2026-07-12T09:00:00.000Z",
  "text": "Getting campaign text messages ahead of the midterms? There could be an AI bot behind it...",
  "author_acct": "npr_national@robot.villas",
  "author_display_name": "NPR Topics: National",
  "author_followers": 5,
  "reblogs_count": 3,
  "tags": ["ai", "politics", "tech"]
}
```

### Pricing

**Pay per result — $0.003 per item.** You are charged only for rows actually delivered; nothing else. No monthly fee, no proxy surcharge.

- 1,000 items ≈ **$3**
- 5,000 items ≈ **$15**

The run stops automatically when your spending limit is reached — no overruns.

### How it works (technical notes)

- Uses each instance's official Mastodon REST API — `/api/v1/timelines/tag`, `/api/v1/accounts`, `/api/v1/trends/*`, `/api/v2/search` — free, public, no key.
- **Resilient by design:** browser-style User-Agent, exponential-backoff retries on 429/5xx/network errors (honoring `Retry-After`), and graceful degradation on hard 4xx. One flaky call never sinks the run.
- **Verified pagination:** `max_id` cursoring for timelines and account posts (via `Link` headers), offset paging for trends.
- Status/account text is returned both as raw `content_html` **and** stripped plain `text`, so it drops straight into analysis or an LLM.

### Honest scope & limits

- **No global timeline mode.** Most instances (including mastodon.social) return `422` for the anonymous public/local timeline. Use **hashtag** mode for a topic feed — it is the keyless way to get a stream of posts by subject.
- **Search is accounts + hashtags, single page (≤40 per term).** Mastodon disables search pagination and full-text **status** search without a login. For posts on a topic, use **hashtag** mode (which paginates deeply).
- **Account mode resolves handles known to the chosen instance.** For a remote user, set `instance` to that user's home server for the fullest history.

### Data compliance

This actor reads only **public** Mastodon data through each instance's official, publicly documented REST API. No login credentials are used and no private content is accessed. Public posts and profiles are intentionally public and suitable for research and business use. Please respect each instance's terms of service and the authors' content.

# Actor input Schema

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

What to scrape. hashtag = posts for a #tag; account = a user's profile + posts; trends = what's trending now; search = find accounts or hashtags by keyword.

## `instance` (type: `string`):

Instance host to query (Mastodon is federated — no global API). Default mastodon.social. For account mode, use the account's HOME instance for best results.

## `searchTerms` (type: `array`):

hashtag mode: tags to pull (with or without #). search mode: keywords. Each term runs as a separate query.

## `accounts` (type: `array`):

Handles to fetch profile + posts for, e.g. 'Gargron' or 'user@another.instance'. Remote handles resolve only if known to the chosen instance.

## `trendType` (type: `string`):

Which trend feed to pull: trending statuses, hashtags, or news links.

## `searchType` (type: `string`):

Search for accounts or hashtags by keyword. Keyless search returns a single page of up to 40 matches per term (Mastodon disables search pagination without a login). Full-text status search also needs an authenticated, opted-in server — use hashtag mode for a topic feed.

## `maxResultsPerTerm` (type: `integer`):

Maximum results per hashtag / account term. Higher values increase cost and run time. Note: in search mode this is capped at 40 (keyless Mastodon search is single-page).

## `onlyMedia` (type: `boolean`):

If true, hashtag mode returns only posts that contain images/video.

## `excludeReplies` (type: `boolean`):

If true, account mode skips the user's replies.

## `excludeReblogs` (type: `boolean`):

If true, account mode skips boosts/reblogs.

## `includeAccountProfile` (type: `boolean`):

If true, emit the account's profile as its own row before its posts.

## Actor input object example

```json
{
  "mode": "hashtag",
  "instance": "mastodon.social",
  "searchTerms": [
    "ai",
    "opensource"
  ],
  "accounts": [],
  "trendType": "statuses",
  "searchType": "accounts",
  "maxResultsPerTerm": 200,
  "onlyMedia": false,
  "excludeReplies": true,
  "excludeReblogs": false,
  "includeAccountProfile": true
}
```

# 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 = {
    "instance": "mastodon.social",
    "searchTerms": [
        "ai",
        "opensource"
    ],
    "accounts": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("claudethegoat/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 = {
    "instance": "mastodon.social",
    "searchTerms": [
        "ai",
        "opensource",
    ],
    "accounts": [],
}

# Run the Actor and wait for it to finish
run = client.actor("claudethegoat/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 '{
  "instance": "mastodon.social",
  "searchTerms": [
    "ai",
    "opensource"
  ],
  "accounts": []
}' |
apify call claudethegoat/mastodon-social-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "SOCIAL MEDIA Scraper - Posts, Hashtags, Accounts & Trends",
        "description": "Scrape Mastodon (any instance) via the official public REST API: hashtag timelines, account posts + profiles, trending statuses/tags/links, and account/hashtag search. No credentials, no proxy required.",
        "version": "0.1",
        "x-build-id": "LrvaQ5JGmbZqc6lgT"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/claudethegoat~mastodon-social-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-claudethegoat-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/claudethegoat~mastodon-social-scraper/runs": {
            "post": {
                "operationId": "runs-sync-claudethegoat-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/claudethegoat~mastodon-social-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-claudethegoat-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",
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "hashtag",
                            "account",
                            "trends",
                            "search"
                        ],
                        "type": "string",
                        "description": "What to scrape. hashtag = posts for a #tag; account = a user's profile + posts; trends = what's trending now; search = find accounts or hashtags by keyword.",
                        "default": "hashtag"
                    },
                    "instance": {
                        "title": "Mastodon instance",
                        "type": "string",
                        "description": "Instance host to query (Mastodon is federated — no global API). Default mastodon.social. For account mode, use the account's HOME instance for best results.",
                        "default": "mastodon.social"
                    },
                    "searchTerms": {
                        "title": "Search terms / hashtags",
                        "type": "array",
                        "description": "hashtag mode: tags to pull (with or without #). search mode: keywords. Each term runs as a separate query.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "accounts": {
                        "title": "Accounts (account mode)",
                        "type": "array",
                        "description": "Handles to fetch profile + posts for, e.g. 'Gargron' or 'user@another.instance'. Remote handles resolve only if known to the chosen instance.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "trendType": {
                        "title": "Trend type (trends mode)",
                        "enum": [
                            "statuses",
                            "tags",
                            "links"
                        ],
                        "type": "string",
                        "description": "Which trend feed to pull: trending statuses, hashtags, or news links.",
                        "default": "statuses"
                    },
                    "searchType": {
                        "title": "Search type (search mode)",
                        "enum": [
                            "accounts",
                            "hashtags"
                        ],
                        "type": "string",
                        "description": "Search for accounts or hashtags by keyword. Keyless search returns a single page of up to 40 matches per term (Mastodon disables search pagination without a login). Full-text status search also needs an authenticated, opted-in server — use hashtag mode for a topic feed.",
                        "default": "accounts"
                    },
                    "maxResultsPerTerm": {
                        "title": "Max results per term",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum results per hashtag / account term. Higher values increase cost and run time. Note: in search mode this is capped at 40 (keyless Mastodon search is single-page).",
                        "default": 200
                    },
                    "onlyMedia": {
                        "title": "Only posts with media (hashtag mode)",
                        "type": "boolean",
                        "description": "If true, hashtag mode returns only posts that contain images/video.",
                        "default": false
                    },
                    "excludeReplies": {
                        "title": "Exclude replies (account mode)",
                        "type": "boolean",
                        "description": "If true, account mode skips the user's replies.",
                        "default": true
                    },
                    "excludeReblogs": {
                        "title": "Exclude reblogs (account mode)",
                        "type": "boolean",
                        "description": "If true, account mode skips boosts/reblogs.",
                        "default": false
                    },
                    "includeAccountProfile": {
                        "title": "Include profile row (account mode)",
                        "type": "boolean",
                        "description": "If true, emit the account's profile as its own row before its posts.",
                        "default": 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```