# Product Hunt Scraper (`crawlerbros/producthunt-scraper`) Actor

Scrape Product Hunt launches, makers, hunters, votes, and topics. Daily leaderboard, by topic, by user, or single product detail.

- **URL**: https://apify.com/crawlerbros/producthunt-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Developer tools, Automation, Other
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 21 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $1.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

## Product Hunt Scraper

Scrape launches, makers, hunters, votes, comments, and topics from [Product Hunt](https://www.producthunt.com). Two paths: a **no-token web path** (default — works out of the box) and an **official GraphQL API path** (free token unlocks richer fields and advanced modes). HTTP-only. No proxy. No cookies.

### Two paths

#### 1. No-token (default) — `dailyLeaderboard` mode only

Just run with `mode=dailyLeaderboard`. Scrapes the public daily leaderboard pages and returns id, name, slug, tagline, votes, comments, daily/weekly/monthly rank, topics, dates, thumbnail. Doesn't include description, makers, hunter, or media.

#### 2. Free Product Hunt API token — full launch metadata + all modes

Get a free Bearer token (instant — no payment, no review):

1. Sign in at https://www.producthunt.com
2. Go to https://api.producthunt.com/v2/oauth/applications
3. Click **Add application**, fill in any name/redirect URL
4. Copy the **Developer Token** (not the OAuth secret)
5. Paste into this actor's `apiToken` field

With a token: full launch metadata (description, makers, hunter, media), and unlocks `topic`, `userLaunches`, `productDetail` modes.

### What this actor does

- Four fetch modes: daily / all launches, by topic, by user (made posts), single product detail
- Returns full launch metadata: name, tagline, description, votes, comments, topics, hunter, makers, media
- Filters: featured-only, date range, min votes / comments, tag intersection
- Sorts: RANKING (daily-rank), VOTES, NEWEST, FEATURED_AT
- Pagination via cursors — fetches up to 5,000 launches per run
- Honors Product Hunt API rate limits (free tier: 50 complexity/15s, 1k/day)

### Output per launch

- `id`, `slug`, `name`, `tagline`, `description`
- `productUrl` — direct link to the product's website
- `phUrl` — the launch page on Product Hunt
- `votesCount`, `commentsCount`, `reviewsCount`
- `featuredAt`, `createdAt` — ISO timestamps
- `topics[]` — slugs (e.g. `["productivity", "saas"]`)
- `topicDetails[]` — full topic objects with `id`, `slug`, `name`
- `hunter` — `{id, username, name, headline, profileImage}`
- `makers[]` — array of users (when `includeMakers=true`)
- `media[]` — screenshots / videos (when `includeMedia=true`)
- `recordType: "post"`, `scrapedAt`

Empty fields are omitted (no nulls).

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `apiToken` | string (secret) | – | Optional. Bearer token from PH OAuth applications page. Without it, only `mode=dailyLeaderboard` works (with limited fields). |
| `mode` | string | `dailyLeaderboard` | `dailyLeaderboard` / `topic` / `userLaunches` / `productDetail` |
| `topicSlugs` | array | `[]` | Required for `mode=topic` (e.g. `["artificial-intelligence"]`) |
| `userSlugs` | array | `[]` | Required for `mode=userLaunches` (e.g. `["rrhoover"]`) |
| `productSlugs` | array | `[]` | Required for `mode=productDetail` (e.g. `["notion","figma"]`) |
| `sortBy` | string | `RANKING` | `RANKING` / `VOTES` / `NEWEST` / `FEATURED_AT` |
| `featuredOnly` | bool | `false` | Only emit launches that were officially featured |
| `dateRangeFrom` | string | – | ISO date — drop launches before this |
| `dateRangeTo` | string | – | ISO date — drop launches after this |
| `minVotes` | int | – | Drop launches below this vote count |
| `minComments` | int | – | Drop launches below this comment count |
| `tagAnyOf` | array | `[]` | Only emit launches tagged with at least one of these topic slugs |
| `includeMakers` | bool | `true` | Include the makers array |
| `includeMedia` | bool | `false` | Include screenshots / videos |
| `maxItems` | int | `50` | Hard cap (1–5000) |

#### Example: top AI launches this year

```json
{
  "apiToken": "<your-token>",
  "mode": "topic",
  "topicSlugs": ["artificial-intelligence"],
  "sortBy": "VOTES",
  "dateRangeFrom": "2025-01-01",
  "minVotes": 500,
  "maxItems": 100
}
````

#### Example: daily leaderboard

```json
{
  "apiToken": "<your-token>",
  "mode": "dailyLeaderboard",
  "sortBy": "RANKING",
  "featuredOnly": true,
  "maxItems": 30
}
```

#### Example: a maker's portfolio

```json
{
  "apiToken": "<your-token>",
  "mode": "userLaunches",
  "userSlugs": ["rrhoover"],
  "maxItems": 50
}
```

#### Example: lookup specific products by slug

```json
{
  "apiToken": "<your-token>",
  "mode": "productDetail",
  "productSlugs": ["notion", "figma", "linear"]
}
```

#### Example: developer-tools launches with media + makers

```json
{
  "apiToken": "<your-token>",
  "mode": "topic",
  "topicSlugs": ["developer-tools"],
  "sortBy": "VOTES",
  "includeMakers": true,
  "includeMedia": true,
  "minVotes": 100,
  "maxItems": 200
}
```

### Use cases

- **VC deal flow** — daily monitor of new launches in your verticals (AI, fintech, dev tools, etc.)
- **Founder competitor research** — track every product launching in your category
- **Product manager benchmarking** — analyze tagline patterns of top-voted launches
- **Growth marketing** — identify emerging tools to integrate or partner with
- **Indie hacker discovery** — find solo-founders and early-stage products
- **Content / newsletter automation** — daily digest of top launches with descriptions
- **Topic / category trend analysis** — vote distributions over time per topic
- **Hunter / maker network mapping** — find prolific hunters / makers in your domain

### FAQ

**Does it require a Product Hunt account?**  Only if you want full fields and access to topic/user/productDetail modes. The default `dailyLeaderboard` mode works without any token — just run it.

**What's the difference between the two paths?**  No-token (web path): id, slug, name, tagline, votes, comments, ranks, topics, dates, thumbnail. With token (GraphQL): all of the above PLUS description, makers, hunter, full media, reviewsCount.

**Is the token paid?**  No, the developer token is free. The free tier is 50 complexity points / 15 seconds (~1k requests/day for typical queries).

**What's the difference between hunter and maker?**  The **hunter** is the person who submitted the launch to Product Hunt (often a community member, not the founder). **Makers** are the people who actually built the product.

**Why are some `productUrl` fields missing?**  Some launches don't list an external website (rare). The actor omits empty fields rather than emit nulls.

**Can I get launches from before Product Hunt's GraphQL API existed?**  Yes — the API has full historical data going back to the site's launch in 2013.

**What does `featured` mean?**  Product Hunt selects a subset of submitted launches to feature on the homepage. Featured launches are eligible for the daily leaderboard. Unfeatured launches still exist in the API but get less visibility.

**How fresh is the data?**  Real-time. New launches appear in the API within seconds of submission.

**Can I scrape comments?**  Comment-count is included; comment text/threads is not part of v1. Use the `phUrl` field to link out to the comment thread.

**What about user reviews?**  `reviewsCount` is included. Per-review text is not part of v1.

**Is there a topic catalog?**  Common topic slugs: `artificial-intelligence`, `developer-tools`, `productivity`, `saas`, `marketing`, `design-tools`, `health-fitness`, `social-media`, `analytics`, `ecommerce`, `mobile`, `chrome-extensions`, `slack-apps`, `crypto`, `web3`. Browse the full catalog at https://www.producthunt.com/topics.

**What's the rate limit?**  Free tier: 50 complexity points / 15s (~1k requests/day). The actor backs off automatically on `429`. For higher throughput, request a quota upgrade from Product Hunt.

**Is this affiliated with Product Hunt?**  No, this actor is third-party and uses the public, official Product Hunt GraphQL API.

# Actor input Schema

## `apiToken` (type: `string`):

Optional Bearer token from https://api.producthunt.com/v2/oauth/applications (free, instant). Without a token, mode=dailyLeaderboard works via public-page scraping with limited fields (no description/makers/media). Token is required for topic, userLaunches, and productDetail modes, and unlocks full launch metadata in dailyLeaderboard.

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

What to fetch. `dailyLeaderboard` returns featured launches sorted by votes; `topic` returns launches in a specific topic; `userLaunches` returns posts by a user; `productDetail` returns a single product by slug.

## `topicSlugs` (type: `array`):

Topic slugs from Product Hunt URLs (e.g. `artificial-intelligence`, `developer-tools`, `productivity`). Required for `mode=topic`.

## `userSlugs` (type: `array`):

Username slugs from Product Hunt URLs (e.g. `rrhoover`, `tibo_maker`). Required for `mode=userLaunches`.

## `productSlugs` (type: `array`):

Product slugs (e.g. `notion`, `figma`). Required for `mode=productDetail`.

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

Sort order for posts. RANKING is daily-rank order; VOTES is most-upvoted overall; NEWEST is most recent; FEATURED\_AT is featured-date order.

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

Only emit launches that were officially featured on the Product Hunt homepage.

## `dateRangeFrom` (type: `string`):

Drop launches posted before this date.

## `dateRangeTo` (type: `string`):

Drop launches posted after this date.

## `minVotes` (type: `integer`):

Drop launches with fewer up-votes than this.

## `minComments` (type: `integer`):

Drop launches with fewer comments than this.

## `tagAnyOf` (type: `array`):

Only emit launches that have at least one of these topic slugs (e.g. `productivity`, `saas`).

## `includeMakers` (type: `boolean`):

Include the makers array (people who built the product). Adds 1 GraphQL field — minor cost.

## `includeMedia` (type: `boolean`):

Include the media array (screenshots, videos uploaded with the launch).

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

Hard cap on emitted records.

## Actor input object example

```json
{
  "mode": "dailyLeaderboard",
  "topicSlugs": [
    "artificial-intelligence"
  ],
  "userSlugs": [],
  "productSlugs": [],
  "sortBy": "RANKING",
  "featuredOnly": false,
  "tagAnyOf": [],
  "includeMakers": true,
  "includeMedia": false,
  "maxItems": 50
}
```

# Actor output Schema

## `products` (type: `string`):

Dataset containing all scraped Product Hunt launches.

# 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": "dailyLeaderboard",
    "topicSlugs": [
        "artificial-intelligence"
    ],
    "userSlugs": [],
    "productSlugs": [],
    "sortBy": "RANKING",
    "featuredOnly": false,
    "tagAnyOf": [],
    "includeMakers": true,
    "includeMedia": false,
    "maxItems": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/producthunt-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": "dailyLeaderboard",
    "topicSlugs": ["artificial-intelligence"],
    "userSlugs": [],
    "productSlugs": [],
    "sortBy": "RANKING",
    "featuredOnly": False,
    "tagAnyOf": [],
    "includeMakers": True,
    "includeMedia": False,
    "maxItems": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/producthunt-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": "dailyLeaderboard",
  "topicSlugs": [
    "artificial-intelligence"
  ],
  "userSlugs": [],
  "productSlugs": [],
  "sortBy": "RANKING",
  "featuredOnly": false,
  "tagAnyOf": [],
  "includeMakers": true,
  "includeMedia": false,
  "maxItems": 50
}' |
apify call crawlerbros/producthunt-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Product Hunt Scraper",
        "description": "Scrape Product Hunt launches, makers, hunters, votes, and topics. Daily leaderboard, by topic, by user, or single product detail.",
        "version": "1.0",
        "x-build-id": "Fm65vY0NyxwOQZcZl"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~producthunt-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-producthunt-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/crawlerbros~producthunt-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-producthunt-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/crawlerbros~producthunt-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-producthunt-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "mode"
                ],
                "properties": {
                    "apiToken": {
                        "title": "Product Hunt API token (optional)",
                        "type": "string",
                        "description": "Optional Bearer token from https://api.producthunt.com/v2/oauth/applications (free, instant). Without a token, mode=dailyLeaderboard works via public-page scraping with limited fields (no description/makers/media). Token is required for topic, userLaunches, and productDetail modes, and unlocks full launch metadata in dailyLeaderboard."
                    },
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "dailyLeaderboard",
                            "topic",
                            "userLaunches",
                            "productDetail"
                        ],
                        "type": "string",
                        "description": "What to fetch. `dailyLeaderboard` returns featured launches sorted by votes; `topic` returns launches in a specific topic; `userLaunches` returns posts by a user; `productDetail` returns a single product by slug.",
                        "default": "dailyLeaderboard"
                    },
                    "topicSlugs": {
                        "title": "Topic slugs (mode=topic)",
                        "type": "array",
                        "description": "Topic slugs from Product Hunt URLs (e.g. `artificial-intelligence`, `developer-tools`, `productivity`). Required for `mode=topic`.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "userSlugs": {
                        "title": "User slugs (mode=userLaunches)",
                        "type": "array",
                        "description": "Username slugs from Product Hunt URLs (e.g. `rrhoover`, `tibo_maker`). Required for `mode=userLaunches`.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "productSlugs": {
                        "title": "Product slugs (mode=productDetail)",
                        "type": "array",
                        "description": "Product slugs (e.g. `notion`, `figma`). Required for `mode=productDetail`.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "sortBy": {
                        "title": "Sort by",
                        "enum": [
                            "RANKING",
                            "VOTES",
                            "NEWEST",
                            "FEATURED_AT"
                        ],
                        "type": "string",
                        "description": "Sort order for posts. RANKING is daily-rank order; VOTES is most-upvoted overall; NEWEST is most recent; FEATURED_AT is featured-date order.",
                        "default": "RANKING"
                    },
                    "featuredOnly": {
                        "title": "Featured only",
                        "type": "boolean",
                        "description": "Only emit launches that were officially featured on the Product Hunt homepage.",
                        "default": false
                    },
                    "dateRangeFrom": {
                        "title": "Date range from (YYYY-MM-DD)",
                        "type": "string",
                        "description": "Drop launches posted before this date."
                    },
                    "dateRangeTo": {
                        "title": "Date range to (YYYY-MM-DD)",
                        "type": "string",
                        "description": "Drop launches posted after this date."
                    },
                    "minVotes": {
                        "title": "Min votes",
                        "minimum": 0,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Drop launches with fewer up-votes than this."
                    },
                    "minComments": {
                        "title": "Min comments",
                        "minimum": 0,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Drop launches with fewer comments than this."
                    },
                    "tagAnyOf": {
                        "title": "Tags / topics filter",
                        "type": "array",
                        "description": "Only emit launches that have at least one of these topic slugs (e.g. `productivity`, `saas`).",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "includeMakers": {
                        "title": "Include makers",
                        "type": "boolean",
                        "description": "Include the makers array (people who built the product). Adds 1 GraphQL field — minor cost.",
                        "default": true
                    },
                    "includeMedia": {
                        "title": "Include media (screenshots / videos)",
                        "type": "boolean",
                        "description": "Include the media array (screenshots, videos uploaded with the launch).",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Hard cap on emitted records.",
                        "default": 50
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
