# Product Hunt Scraper (`scrapeworks/product-hunt-scraper`) Actor

Scrape Product Hunt launches in bulk via the official API: name, tagline, upvotes, comments, review count and rating, topics, makers, hunter and launch date. Filter by topic and date range; sort by ranking, votes or newest; paginate deep. Export to JSON, CSV or Excel.

- **URL**: https://apify.com/scrapeworks/product-hunt-scraper.md
- **Developed by:** [Nicolas van Arkens](https://apify.com/scrapeworks) (community)
- **Categories:** Marketing, Lead generation, Business
- **Stats:** 1 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.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.

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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## Product Hunt Scraper

**Scrape Product Hunt launches in bulk** — names, taglines, descriptions, upvotes, comments, review counts & ratings, topics, makers, the hunter, and launch dates — straight from Product Hunt's **official public API**. Filter by **topic** and **date range**, sort by ranking / votes / newest, and export thousands of launches to JSON, CSV, or Excel.

Perfect for market research, competitor tracking, lead generation, trend analysis, and building datasets of new products.

### What you get (one row per launch)

| Field | Description |
|---|---|
| `id` | Product Hunt post ID |
| `name` | Launch / product name |
| `tagline` | One-line pitch shown on the card |
| `description` | Longer product description |
| `slug` | URL slug |
| `url` | The producthunt.com launch page |
| `website` | The product's own website (Product Hunt "visit" link) |
| `votesCount` | Number of upvotes |
| `commentsCount` | Number of comments |
| `reviewsCount` | Number of reviews |
| `reviewsRating` | Average review rating (0–5) |
| `topics` | Topic names the launch is filed under |
| `topicSlugs` | Topic slugs (for re-querying) |
| `makers` | List of makers `{name, username}` |
| `makerUsernames` | Maker usernames only |
| `hunterName` / `hunterUsername` | Who hunted (posted) the launch |
| `thumbnailUrl` | Launch thumbnail image |
| `createdAt` | ISO timestamp the launch was posted |
| `featuredAt` | ISO timestamp it was featured (if featured) |
| `postedDate` | `YYYY-MM-DD` the launch was posted |
| `query` | Which topic / feed produced the row |
| `scrapedAt` | When this actor fetched the row |

### Authentication — free, one-time, ~2 minutes

Product Hunt's data comes from its **official API**, which needs a free access token (this keeps the actor reliable — the public website itself is behind a bot wall, the API is not). Choose the easiest option:

**Option A — Developer Token (easiest):**
1. Go to **https://www.producthunt.com/v2/oauth/applications**
2. Click **Add an application** — give it any name and any redirect URL (e.g. `https://example.com`).
3. Open the application and click **Create Developer Token**.
4. Paste that token into the **`developerToken`** field. Done.

**Option B — API Client ID + Secret:** from the same application page, copy the **API Key** (Client ID) and **API Secret** into `apiClientId` and `apiClientSecret`. The actor fetches a read-only token for you automatically (OAuth `client_credentials` — no login).

### Input example

```json
{
  "developerToken": "YOUR_PRODUCT_HUNT_DEVELOPER_TOKEN",
  "topics": ["artificial-intelligence", "developer-tools", "productivity"],
  "sortBy": "ranking",
  "maxResultsPerQuery": 500,
  "maxResults": 1500
}
````

Pull every launch in a date window instead:

```json
{
  "developerToken": "YOUR_PRODUCT_HUNT_DEVELOPER_TOKEN",
  "postedAfter": "2024-01-01",
  "postedBefore": "2024-12-31",
  "sortBy": "newest",
  "maxResultsPerQuery": 5000
}
```

Leave `topics` empty to scan the **whole global launch feed**. Add topic slugs (from a topic's URL, e.g. `producthunt.com/topics/`**`developer-tools`**) to scrape each topic deep and independently — more topics = more launches.

### Output sample

```json
{
  "id": "123456",
  "name": "Acme AI Writer",
  "tagline": "Write blog posts 10x faster with AI",
  "description": "Acme AI Writer helps you draft, edit and publish content.",
  "slug": "acme-ai-writer",
  "url": "https://www.producthunt.com/posts/acme-ai-writer",
  "website": "https://www.producthunt.com/r/abc123",
  "votesCount": 842,
  "commentsCount": 57,
  "reviewsCount": 12,
  "reviewsRating": 4.6,
  "topics": ["Artificial Intelligence", "Writing"],
  "topicSlugs": ["artificial-intelligence", "writing"],
  "makers": [{ "name": "Jane Maker", "username": "janemaker" }],
  "makerUsernames": ["janemaker"],
  "hunterName": "Hunter Harry",
  "hunterUsername": "harryhunts",
  "thumbnailUrl": "https://ph-files.imgix.net/thumb.png",
  "createdAt": "2024-06-01T07:01:00Z",
  "featuredAt": "2024-06-01T07:01:00Z",
  "postedDate": "2024-06-01",
  "query": "topic:artificial-intelligence",
  "scrapedAt": "2026-07-19T00:00:00Z"
}
```

### Use cases

- **Market & trend research** — track which products, topics and categories are getting traction over time.
- **Competitor monitoring** — watch every new launch in your space (your topics) and how much attention it gets.
- **Lead generation** — build lists of makers and new products in target topics.
- **Content & newsletters** — power a "top launches this week/month" digest with structured data.
- **Datasets** — assemble a historical corpus of launches for analysis or ML.

### FAQ

**Do I need a paid Product Hunt account?** No. A free account and a free developer token are enough.

**Why does it use the API instead of scraping the website?** The producthunt.com website is protected by a Cloudflare challenge that blocks non-browser scrapers. The official API returns the same launch data as clean, stable JSON — far more reliable and lower-maintenance.

**How many launches can I get?** Thousands per run. Set `maxResultsPerQuery` (per topic / feed) and an optional overall `maxResults`. The actor paginates deep automatically and paces itself against Product Hunt's rate limits.

**How is it billed?** Pay-per-result — you're charged once per launch returned to your dataset. Failed/auth-error and empty pages are never charged.

**Can I get every launch from a specific day/month/year?** Yes — set `postedAfter` and `postedBefore` (format `YYYY-MM-DD`) and sort by `newest`.

**What if I hit a rate limit?** The actor reads Product Hunt's rate-limit headers and automatically waits for the window to reset, then continues — no errors, it just paces itself.

# Actor input Schema

## `developerToken` (type: `string`):

A Product Hunt API access token. THE EASIEST way to authenticate. Get one free in ~2 minutes: go to https://www.producthunt.com/v2/oauth/applications, click 'Add an application' (any name/redirect URL, e.g. https://example.com), open the app, and click 'Create Developer Token'. Paste that token here. Leave this empty ONLY if you are using the API Client ID + Secret fields instead.

## `apiClientId` (type: `string`):

Alternative to the Developer Token: the 'API Key' (Client ID) of your Product Hunt application from https://www.producthunt.com/v2/oauth/applications. Provide this together with the API Client Secret and the actor will fetch a read-only access token for you (OAuth client\_credentials - no login needed). Ignored if a Developer Token is set.

## `apiClientSecret` (type: `string`):

The 'API Secret' (Client Secret) of your Product Hunt application, paired with the API Client ID above. Ignored if a Developer Token is set.

## `topics` (type: `array`):

Optional list of Product Hunt topic slugs to scrape - EACH topic is queried and paginated deep independently, so more topics = more launches. Use the slug from a topic's URL, e.g. https://www.producthunt.com/topics/artificial-intelligence -> 'artificial-intelligence'. Display names ('Developer Tools') and full topic URLs are also accepted. LEAVE EMPTY to scan the WHOLE global launch feed instead of specific topics.

## `sortBy` (type: `string`):

How to order the launches within each query. 'ranking' = Product Hunt's ranking (best for a topic's top launches), 'votes' = most upvoted first, 'newest' = most recently created first, 'featured' = most recently featured on the homepage first.

## `postedAfter` (type: `string`):

Only include launches posted ON OR AFTER this date (UTC). Format YYYY-MM-DD, e.g. 2024-01-01. Combine with 'Posted before' to pull a specific historical window - great for bulk (e.g. every launch of 2024). Leave empty for no lower bound.

## `postedBefore` (type: `string`):

Only include launches posted ON OR BEFORE this date (UTC). Format YYYY-MM-DD, e.g. 2024-12-31. Leave empty for no upper bound.

## `featuredOnly` (type: `boolean`):

If enabled, only return launches that were FEATURED on the Product Hunt homepage (the curated ones), skipping unfeatured submissions.

## `maxResultsPerQuery` (type: `integer`):

Maximum launches to return for EACH topic (or for the global feed when no topics are set). The actor paginates automatically (20 launches per API request) and stops at this cap or at the real end of the feed. Set high to pull a whole topic; lower it to sample.

## `maxResults` (type: `integer`):

Optional overall cap across ALL topics/queries combined. Leave empty for no overall cap (each topic is still bounded by 'Max results per topic / query'). Useful to cap total billed rows for a run.

## Actor input object example

```json
{
  "topics": [
    "artificial-intelligence",
    "developer-tools",
    "productivity"
  ],
  "sortBy": "ranking",
  "featuredOnly": false,
  "maxResultsPerQuery": 1000
}
```

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapeworks/product-hunt-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("scrapeworks/product-hunt-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 '{}' |
apify call scrapeworks/product-hunt-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Product Hunt Scraper",
        "description": "Scrape Product Hunt launches in bulk via the official API: name, tagline, upvotes, comments, review count and rating, topics, makers, hunter and launch date. Filter by topic and date range; sort by ranking, votes or newest; paginate deep. Export to JSON, CSV or Excel.",
        "version": "0.1",
        "x-build-id": "OsMUvabwdYpaBzmRf"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapeworks~product-hunt-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapeworks-product-hunt-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/scrapeworks~product-hunt-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapeworks-product-hunt-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/scrapeworks~product-hunt-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapeworks-product-hunt-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": {
                    "developerToken": {
                        "title": "Product Hunt Developer Token (easiest auth)",
                        "type": "string",
                        "description": "A Product Hunt API access token. THE EASIEST way to authenticate. Get one free in ~2 minutes: go to https://www.producthunt.com/v2/oauth/applications, click 'Add an application' (any name/redirect URL, e.g. https://example.com), open the app, and click 'Create Developer Token'. Paste that token here. Leave this empty ONLY if you are using the API Client ID + Secret fields instead."
                    },
                    "apiClientId": {
                        "title": "API Client ID (alternative auth)",
                        "type": "string",
                        "description": "Alternative to the Developer Token: the 'API Key' (Client ID) of your Product Hunt application from https://www.producthunt.com/v2/oauth/applications. Provide this together with the API Client Secret and the actor will fetch a read-only access token for you (OAuth client_credentials - no login needed). Ignored if a Developer Token is set."
                    },
                    "apiClientSecret": {
                        "title": "API Client Secret (alternative auth)",
                        "type": "string",
                        "description": "The 'API Secret' (Client Secret) of your Product Hunt application, paired with the API Client ID above. Ignored if a Developer Token is set."
                    },
                    "topics": {
                        "title": "Topics (optional)",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Optional list of Product Hunt topic slugs to scrape - EACH topic is queried and paginated deep independently, so more topics = more launches. Use the slug from a topic's URL, e.g. https://www.producthunt.com/topics/artificial-intelligence -> 'artificial-intelligence'. Display names ('Developer Tools') and full topic URLs are also accepted. LEAVE EMPTY to scan the WHOLE global launch feed instead of specific topics.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "sortBy": {
                        "title": "Sort order",
                        "enum": [
                            "ranking",
                            "votes",
                            "newest",
                            "featured"
                        ],
                        "type": "string",
                        "description": "How to order the launches within each query. 'ranking' = Product Hunt's ranking (best for a topic's top launches), 'votes' = most upvoted first, 'newest' = most recently created first, 'featured' = most recently featured on the homepage first.",
                        "default": "ranking"
                    },
                    "postedAfter": {
                        "title": "Posted after (optional)",
                        "type": "string",
                        "description": "Only include launches posted ON OR AFTER this date (UTC). Format YYYY-MM-DD, e.g. 2024-01-01. Combine with 'Posted before' to pull a specific historical window - great for bulk (e.g. every launch of 2024). Leave empty for no lower bound."
                    },
                    "postedBefore": {
                        "title": "Posted before (optional)",
                        "type": "string",
                        "description": "Only include launches posted ON OR BEFORE this date (UTC). Format YYYY-MM-DD, e.g. 2024-12-31. Leave empty for no upper bound."
                    },
                    "featuredOnly": {
                        "title": "Featured launches only",
                        "type": "boolean",
                        "description": "If enabled, only return launches that were FEATURED on the Product Hunt homepage (the curated ones), skipping unfeatured submissions.",
                        "default": false
                    },
                    "maxResultsPerQuery": {
                        "title": "Max results per topic / query",
                        "minimum": 1,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Maximum launches to return for EACH topic (or for the global feed when no topics are set). The actor paginates automatically (20 launches per API request) and stops at this cap or at the real end of the feed. Set high to pull a whole topic; lower it to sample.",
                        "default": 1000
                    },
                    "maxResults": {
                        "title": "Max results overall (optional)",
                        "minimum": 1,
                        "maximum": 500000,
                        "type": "integer",
                        "description": "Optional overall cap across ALL topics/queries combined. Leave empty for no overall cap (each topic is still bounded by 'Max results per topic / query'). Useful to cap total billed rows for a run."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
