# Tiny Startups Scraper (`automation-lab/tiny-startups-scraper`) Actor

Scrape Tiny Startups launch, founder, vote, backlink, and deal data for startup lead generation and market research.

- **URL**: https://apify.com/automation-lab/tiny-startups-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Lead generation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## Tiny Startups Scraper

Collect public startup launch data from Tiny Startups in minutes.

This Apify Actor extracts launch cards, founder/submitter details, backlinks, rankings, vote counts, and deal metadata from the public Tiny Startups website.

Use it for indie-founder lead generation, startup scouting, product research, outreach lists, and market monitoring.

### What does Tiny Startups Scraper do?

Tiny Startups Scraper turns public Tiny Startups pages and API feeds into a structured dataset.

It can collect this week's launches, archive listings, all-time top startups, keyword search results, the current Startup of the Day, and exclusive deal listings.

Each saved item is a clean startup record with names, URLs, categories, votes, founder metadata, and timestamps.

### Who is it for?

#### Founder outreach teams

Find founders launching new products and build outreach lists while the launch is fresh.

#### Startup investors and acquirers

Monitor early traction signals such as upvotes, category, backlink status, and launch recency.

#### Agencies and consultants

Discover companies that may need design, SEO, automation, analytics, or growth services.

#### Indie hackers

Research launch positioning, taglines, categories, and offers from other bootstrapped products.

#### Market researchers

Export structured startup discovery data for trend analysis and category tracking.

### Why use this Actor?

- 🚀 Fast HTTP-only collection without a browser
- 🧭 Multiple feeds: weekly, archive, all-time, search, today, deals
- 🔗 Direct website and Tiny Startups listing URLs
- 👤 Creator or submitter fields when public
- 🎁 Deal-code fields for discount monitoring
- 📊 Dataset ready for CSV, JSON, Excel, Google Sheets, APIs, and webhooks

### What data can it extract?

| Field | Description |
| --- | --- |
| `startupName` | Public startup name |
| `tagline` | Short launch tagline |
| `description` | Longer public description when available |
| `websiteUrl` | Startup website URL |
| `listingUrl` | Tiny Startups listing URL |
| `logoUrl` | Logo image URL |
| `featuredImageUrl` | Featured image when exposed |
| `category` | Tiny Startups category |
| `rank` | Rank in ranked feeds |
| `upvoteCount` | Public upvote count |
| `launchDate` | Launch date or daily feature date |
| `creatorName` | Creator or submitter name when public |
| `creatorUsername` | Creator username when public |
| `dealHeadline` | Deal headline for deal-feed records |
| `dealCode` | Public coupon code when present |
| `sourceMode` | Feed used to collect the record |
| `scrapedAt` | ISO timestamp for the run |

### How much does it cost to scrape Tiny Startups?

This Actor uses pay-per-event pricing.

You pay a small start fee when a run starts and a tiny per-result fee for each startup record saved to the dataset.

Actual configured event prices for the first paid tier are:

| Charge event | When it is charged | BRONZE price |
| --- | --- | ---: |
| Run started | Once per Actor run | $0.005 |
| Result extracted | Per startup saved | $0.00005 |

Example estimates at BRONZE pricing:

| Run size | Estimated result fees | Start fee | Estimated total |
| --- | ---: | ---: | ---: |
| 25 startups | $0.00125 | $0.005 | ~$0.00625 |
| 100 startups | $0.00500 | $0.005 | ~$0.01000 |
| 1,000 startups | $0.05000 | $0.005 | ~$0.05500 |

Free Apify plan users can run small tests first. A 20-result prefill run is approximately $0.006 at BRONZE-equivalent pricing before any Apify plan allowances or platform-specific display rounding.

The Apify Actor page always shows the final price confirmation before you start a run.

### Input options

#### Collection mode

Choose the Tiny Startups feed to collect.

- `weekly` — this week's launches
- `archive` — archive feed
- `allTime` — all-time top startups
- `search` — keyword search results
- `today` — Startup of the Day
- `deals` — exclusive deals feed

#### Search queries

Use this only with `search` mode.

Example queries:

- `ai`
- `developer tools`
- `productivity`
- `marketing`

#### Maximum startups

Set the maximum number of records to save.

Start with 25 for testing.

Increase once your workflow is ready.

#### Include deals

When enabled, the Actor also appends startups from the deals feed if there is room under your maximum.

### Example input

```json
{
  "mode": "weekly",
  "maxItems": 25,
  "includeDeals": false
}
````

### Search input example

```json
{
  "mode": "search",
  "searchQueries": ["ai", "developer tools"],
  "maxItems": 50
}
```

### Output example

```json
{
  "startupId": "cmoyhvv8e001fzerc44xqjstc",
  "startupName": "FlashTTS",
  "tagline": "ElevenLabs alternative. Better price, same quality.",
  "websiteUrl": "https://www.flashtts.com/",
  "listingUrl": "https://www.tinystartups.com/startup/flashtts",
  "category": "Productivity",
  "rank": 1,
  "upvoteCount": 98,
  "creatorName": "Zeke Yeager",
  "sourceMode": "weekly",
  "scrapedAt": "2026-05-26T00:00:00.000Z"
}
```

### How to run it

1. Open the Actor on Apify.
2. Select a collection mode.
3. Set a small maximum for your first run.
4. Add search queries if using search mode.
5. Click Start.
6. Download results as CSV, JSON, Excel, or through the API.

### Tips for better results

- Use `weekly` for fresh launch monitoring.
- Use `search` for niche prospecting.
- Use `deals` to find startups with active promotional offers.
- Use `allTime` to benchmark high-performing listings.
- Schedule daily or weekly runs for trend tracking.

### Integrations

Send results to Google Sheets for outreach.

Push new launches to Slack with Apify webhooks.

Connect the dataset to a CRM enrichment workflow.

Use Make or Zapier to trigger emails for matching categories.

Export JSON into your own lead-scoring pipeline.

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/tiny-startups-scraper').call({
  mode: 'weekly',
  maxItems: 25
});
console.log(run.defaultDatasetId);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('MY-APIFY-TOKEN')
run = client.actor('automation-lab/tiny-startups-scraper').call(run_input={
    'mode': 'weekly',
    'maxItems': 25,
})
print(run['defaultDatasetId'])
```

### API usage with cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~tiny-startups-scraper/runs?token=MY-APIFY-TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"mode":"weekly","maxItems":25}'
```

### MCP usage

Use this Actor from Apify MCP with Claude Code or Claude Desktop.

MCP tool URL:

```text
https://mcp.apify.com/?tools=automation-lab/tiny-startups-scraper
```

Claude Code setup:

```bash
claude mcp add apify-tiny-startups --transport http https://mcp.apify.com/?tools=automation-lab/tiny-startups-scraper
```

Claude Desktop JSON config:

```json
{
  "mcpServers": {
    "apify-tiny-startups": {
      "url": "https://mcp.apify.com/?tools=automation-lab/tiny-startups-scraper"
    }
  }
}
```

Example prompts:

- "Collect this week's Tiny Startups launches and summarize the top categories."
- "Find AI startups on Tiny Startups and prepare an outreach table."
- "Get current Tiny Startups deals and extract coupon codes."

### Scheduling

You can schedule this Actor to run daily or weekly.

A daily run is useful for Startup of the Day and fresh launches.

A weekly run is useful for lead generation and trend reports.

### Data quality notes

The Actor only extracts data that Tiny Startups exposes publicly.

Some optional fields may be empty for archive or daily records.

Deal fields are populated only for the deals feed or when deals are appended.

### Legality

This Actor collects publicly available information.

You are responsible for using exported data in accordance with applicable laws, Tiny Startups terms, and privacy rules.

Avoid spam and respect opt-out requests in outreach workflows.

### FAQ

#### Can I scrape Tiny Startups search results?

Yes. Select `search` mode and provide one or more search queries.

#### Does this include private founder contact data?

No. It only exports public fields exposed by Tiny Startups.

### Troubleshooting

#### Why did I get fewer results than requested?

The selected feed may contain fewer public records than your maximum, especially `today` and `deals` modes.

#### Why are deal fields empty?

Deal fields are only available for `deals` mode or when `includeDeals` is enabled and deal records are appended.

#### Why do I need search queries?

Search queries are required only when `mode` is `search`.

### Related scrapers

Explore related automation-lab Actors for startup research, lead generation, SEO, and website enrichment on Apify.

- [Website Emails Scraper](https://apify.com/automation-lab/website-emails-scraper) — enrich startup website URLs with public email/contact discoveries.
- [Product Hunt Scraper](https://apify.com/automation-lab/producthunt-scraper) — compare Tiny Startups launches with Product Hunt launches and rankings.
- [Google Search Scraper](https://apify.com/automation-lab/google-search-scraper) — find additional public references, competitors, and founder profiles.
- [LinkedIn Company Scraper](https://apify.com/automation-lab/linkedin-company-scraper) — enrich companies that have public LinkedIn company pages.

Use Tiny Startups Scraper together with website enrichment Actors to turn launch records into complete lead profiles.

### Changelog

#### 0.1

Initial implementation with weekly, archive, all-time, search, today, and deals modes.

### Support

If the website changes or you need another field, open an issue on the Actor page.

### Workflow examples

#### Weekly founder prospecting

Run `weekly` mode every Monday, export the dataset to Google Sheets, and review the newest launches before writing outreach.

Focus on records with complete `websiteUrl`, `category`, `tagline`, and `creatorName` fields.

Add your own columns for fit score, outreach status, and next action.

#### Category research

Use `search` mode with category-like terms such as `ai`, `developer tools`, `marketing`, or `productivity`.

Compare taglines and descriptions to understand positioning patterns in each niche.

Export the results to CSV and group by `category` or keyword source.

#### Deal monitoring

Use `deals` mode, or enable `includeDeals`, when you want promotional offers and coupon fields.

Watch `dealHeadline` and `dealCode` for public offers that may matter to partnership, affiliate, or marketplace workflows.

### Responsible outreach notes

Tiny Startups data is best used as a starting point for research, not as permission to send bulk messages.

Validate high-value leads manually before contacting founders.

Personalize outreach based on the actual launch, website, and category.

Respect opt-outs, local privacy laws, and the recipient's communication preferences.

# Actor input Schema

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

Choose which Tiny Startups public feed to scrape.

## `searchQueries` (type: `array`):

Keywords to search on Tiny Startups. Used only when collection mode is Search results.

## `maxItems` (type: `integer`):

Maximum number of startup records to save. Keep this low for a first test run.

## `includeDeals` (type: `boolean`):

Also append startups currently shown in the Tiny Startups deals feed when there is room under the maximum.

## Actor input object example

```json
{
  "mode": "weekly",
  "searchQueries": [
    "ai",
    "developer tools"
  ],
  "maxItems": 20,
  "includeDeals": false
}
```

# Actor output Schema

## `startups` (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": "weekly",
    "searchQueries": [
        "ai",
        "developer tools"
    ],
    "maxItems": 20,
    "includeDeals": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/tiny-startups-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": "weekly",
    "searchQueries": [
        "ai",
        "developer tools",
    ],
    "maxItems": 20,
    "includeDeals": False,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/tiny-startups-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": "weekly",
  "searchQueries": [
    "ai",
    "developer tools"
  ],
  "maxItems": 20,
  "includeDeals": false
}' |
apify call automation-lab/tiny-startups-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Tiny Startups Scraper",
        "description": "Scrape Tiny Startups launch, founder, vote, backlink, and deal data for startup lead generation and market research.",
        "version": "0.1",
        "x-build-id": "nDVXWFUfgRjGfVP6F"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~tiny-startups-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-tiny-startups-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/automation-lab~tiny-startups-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-tiny-startups-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/automation-lab~tiny-startups-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-tiny-startups-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": "Collection mode",
                        "enum": [
                            "weekly",
                            "archive",
                            "allTime",
                            "search",
                            "today",
                            "deals"
                        ],
                        "type": "string",
                        "description": "Choose which Tiny Startups public feed to scrape.",
                        "default": "weekly"
                    },
                    "searchQueries": {
                        "title": "Search queries",
                        "type": "array",
                        "description": "Keywords to search on Tiny Startups. Used only when collection mode is Search results.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Maximum startups",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of startup records to save. Keep this low for a first test run.",
                        "default": 50
                    },
                    "includeDeals": {
                        "title": "Include deal listings",
                        "type": "boolean",
                        "description": "Also append startups currently shown in the Tiny Startups deals feed when there is room under the maximum.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
