# ProductHunt Leaderboard Scraper (`ecomscrape/producthunt-leaderboard-scraper`) Actor

Product Hunt Leaderboard Scraper automates extraction of trending products, rankings, votes, and launch metrics from daily, weekly, and monthly leaderboards. Efficiently collect product intelligence for competitive analysis, trend research, and market opportunity identification.

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

## Pricing

from $1.50 / 1,000 results

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## Contact

If you encounter any issues or need to exchange information, please feel free to contact us through the following link:
[My posts](https://apify.com/ecomscrape)
## Product Hunt Leaderboard Scraper: Extract Top Product Rankings & Launch Data

### Introduction

Product Hunt is the world's leading platform for discovering new products, startups, and innovations, attracting millions of entrepreneurs, investors, and early adopters. The platform's leaderboard system showcases the most popular products launched each day, week, and month, ranked by community votes and engagement. This competitive ranking mechanism makes Product Hunt leaderboards a goldmine of data for understanding product launch success, market trends, and emerging technologies.

For product managers, startup founders, investors, and market researchers, accessing structured leaderboard data is invaluable for competitive intelligence, trend analysis, and launch strategy optimization. However, manually tracking leaderboard positions across multiple time periods is tedious and prevents systematic analysis of launch patterns and success factors.

The Product Hunt Leaderboard Scraper automates extraction of comprehensive ranking data, enabling systematic analysis of product launches, competitive positioning, and market trends that would otherwise require extensive manual effort.

### Scraper Overview

The Product Hunt Leaderboard Scraper is a specialized tool designed to extract detailed product ranking data from Product Hunt's daily, weekly, and monthly leaderboards. It captures comprehensive launch metrics including vote counts, rankings, product details, community engagement, and temporal data.

The scraper offers flexible URL-based extraction, configurable item limits, and robust error handling through the `ignore_url_failures` parameter. It's valuable for startup founders analyzing competitor launches, investors tracking emerging products, product managers researching market trends, and content creators identifying viral products.

The tool extracts rich metadata including product slugs, taglines, featured comments, topic classifications, and multiple ranking dimensions (daily, weekly, monthly), enabling multi-faceted analysis of launch success factors and product performance patterns.

### Input and Output Details

Example url 1: https://www.producthunt.com/leaderboard/daily/2026/4/9

Example url 2: https://www.producthunt.com/leaderboard/weekly/2026/15

Example url 3: https://www.producthunt.com/leaderboard/monthly/2026/4

Example Screenshot of posts list page:
    
![](https://i.ibb.co/Zpcq3hMX/Screenshot-from-2026-04-09-21-39-13.png)

#### Input Format

```json
{
  "urls": [
    "https://www.producthunt.com/leaderboard/monthly/2026/4"
  ],
  "max_items_per_url": 100,
  "ignore_url_failures": true
}
````

**The `urls` parameter**: Add URLs of Product Hunt leaderboard pages. Supported formats include:

- Daily leaderboards: `/leaderboard/daily/YYYY/M/D`
- Weekly leaderboards: `/leaderboard/weekly/YYYY/W`
- Monthly leaderboards: `/leaderboard/monthly/YYYY/M`

**The `max_items_per_url` parameter**: Limit products scraped per leaderboard page. Default is 20, increase to 100+ for comprehensive monthly data extraction.

**The `ignore_url_failures` parameter**: When `true`, continues scraping even if specific URLs fail, ensuring one problematic date doesn't halt batch processing.

#### Output Format

```json
[
  {
  "id": "1094681",
  "promoted_pill_image_url": "/i/aaf721a5d9644cf0b8a2424fa625730d222578a376471665f5793eb0c5495a6b",
  "name": "Brila",
  "slug": "brila-2",
  "tagline": "One-page websites from real Google Maps reviews",
  "hide_votes_count": false,
  "redirect_to_product": null,
  "product": {
    "__typename": "Product",
    "id": "1178396",
    "slug": "brila-2",
    "is_subscribed": false
  },
  "featured_comment": null,
  "thumbnail_image_uuid": "6e8a39c7-ec23-46e5-9962-0ad93d097fc0.png",
  "featured_at": "2026-04-09T00:01:00-07:00",
  "scheduled_at": "2026-04-09T00:01:00-07:00",
  "created_at": "2026-04-09T00:01:00-07:00",
  "is_subscribed": false,
  "shortened_url": "/r/p/1094681",
  "daily_rank": "1",
  "weekly_rank": "3",
  "monthly_rank": "52",
  "randomization_status": {
    "__typename": "FeedRandomizationStatus",
    "randomize_order": false,
    "random_day": false,
    "active": false,
    "next_transition_at": null
  },
  "friend_voters": {
    "__typename": "UserConnection",
    "edges": [],
    "total_count": 0
  },
  "topics": {
    "__typename": "TopicConnection",
    "edges": [
      {
        "__typename": "TopicEdge",
        "node": {
          "__typename": "Topic",
          "id": "243",
          "slug": "website-builder",
          "name": "Website Builder"
        }
      },
      {
        "__typename": "TopicEdge",
        "node": {
          "__typename": "Topic",
          "id": "268",
          "slug": "artificial-intelligence",
          "name": "Artificial Intelligence"
        }
      },
      {
        "__typename": "TopicEdge",
        "node": {
          "__typename": "Topic",
          "id": "1260",
          "slug": "alpha",
          "name": "Alpha"
        }
      }
    ]
  },
  "contest": {
    "__typename": "Contest",
    "id": "alpha-day",
    "name": "Alpha Day",
    "slug": "alpha-day",
    "metadata": {
      "theme": "alpha",
      "sponsor": "Product Hunt",
      "title": "Be the first to try something new",
      "subtitle": "Alpha products are launching for the first time ever. Try them, leave feedback, and help shape what's next.",
      "description": "Comments on alpha launches and comments by alpha makers will earn 3x points today.",
      "sidebar_headline": "Debut launches get a boost",
      "sidebar_subheadline": "Comments earn 3x points. Makers commenting on other makers’ launches = double boost.",
      "sidebar_cta_label": "Vote now",
      "sidebar_cta_url": "/contests/alpha-day?ref=sidebar"
    }
  },
  "product_state": "default",
  "has_voted": false,
  "latest_score": 578,
  "launch_day_score": 578,
  "disabled_when_scheduled": true,
  "updated_at": "2026-04-09T07:32:28-07:00",
  "embargo_preview_at": null,
  "comments_count": 114,
  "from_url": "https://www.producthunt.com/leaderboard/daily/2026/4/9"
}
]
```

The scraper returns detailed product ranking data:

- **ID**: Unique Product Hunt post identifier. *Critical for tracking products across time periods and preventing duplicates in analysis.*

- **Promoted Pill Image URL**: Promotional badge image if product is sponsored. *Identifies paid promotions vs. organic launches.*

- **Name**: Product name. *Essential for product identification and competitive tracking.*

- **Slug**: URL-friendly product identifier. *Enables direct linking and consistent product tracking across leaderboards.*

- **Tagline**: One-line product description. *Reveals positioning strategy and value proposition messaging.*

- **Hide Votes Count**: Boolean indicating if votes are hidden. *Signals competitive concerns or strategic voting concealment.*

- **Redirect To Product**: External product URL. *Enables traffic analysis and product website examination.*

- **Product**: Detailed product object with additional metadata. *Contains comprehensive product information beyond basic fields.*

- **Featured Comment**: Highlighted community comment. *Provides social proof, user feedback, and engagement quality indicators.*

- **Thumbnail Image UUID**: Product thumbnail identifier. *Enables visual tracking and image asset management.*

- **Featured At**: Timestamp when product was featured. *Critical for launch timing analysis and temporal trend identification.*

- **Scheduled At**: Planned launch time if pre-scheduled. *Reveals launch planning strategies and optimal timing patterns.*

- **Created At**: Post creation timestamp. *Tracks preparation time before launch for strategic insights.*

- **Is Subscribed**: User subscription status. *Indicates tracking or follow-up interest.*

- **Shortened URL**: Product Hunt short link. *Facilitates sharing and referral tracking.*

- **Daily Rank**: Position in daily leaderboard. *Core metric for launch day success measurement.*

- **Weekly Rank**: Position in weekly leaderboard. *Shows sustained performance beyond launch day.*

- **Monthly Rank**: Position in monthly leaderboard. *Indicates long-term product impact and staying power.*

- **Randomization Status**: Algorithm randomization indicator. *Important for understanding ranking mechanics.*

- **Friend Voters**: Voters from user's network. *Signals social network effects on product success.*

- **Topics**: Product category tags. *Enables category-specific analysis and trend identification by vertical.*

- **Contest**: Associated contest or competition. *Identifies products participating in special events.*

- **Product State**: Current product status. *Tracks active vs. inactive products.*

- **Has Voted**: User voting status. *For authenticated scraping, tracks personal engagement.*

- **Latest Score**: Most recent vote count. *Real-time popularity metric for dynamic tracking.*

- **Launch Day Score**: Votes received on launch day. *Key success indicator for launch effectiveness.*

- **Disabled When Scheduled**: Scheduling restriction status. *Technical metadata about launch configuration.*

- **Updated At**: Last modification timestamp. *Tracks product updates and post-launch changes.*

- **Embargo Preview At**: Preview embargo timestamp. *Reveals early access strategies.*

- **Comments Count**: Total comment quantity. *Measures community engagement and discussion volume.*

Each field enables analysis of launch strategies, success patterns, competitive positioning, and temporal trends in product launches.

### Usage Guide

#### Setting Up Leaderboard Extraction

**Step 1: Identify Target Leaderboards**

Navigate to Product Hunt leaderboards and select time periods:

- **Daily leaderboards**: Track specific launch days or competitive benchmarking
- **Weekly leaderboards**: Analyze sustained performance beyond launch
- **Monthly leaderboards**: Identify breakout products and long-term trends

Copy the leaderboard URLs you want to scrape.

**Step 2: Configure Extraction Parameters**

Set `max_items_per_url` based on analysis depth:

- 20-50 items: Top products only
- 100+ items: Comprehensive coverage for statistical analysis
- Monthly leaderboards may have 100+ products

Enable `ignore_url_failures` for batch date ranges to ensure continuity.

**Step 3: Build URL Collections**

For temporal analysis, create URL lists spanning multiple periods:

```json
{
  "urls": [
    "https://www.producthunt.com/leaderboard/daily/2026/4/1",
    "https://www.producthunt.com/leaderboard/daily/2026/4/2",
    "https://www.producthunt.com/leaderboard/daily/2026/4/3"
  ]
}
```

#### Best Practices

**Temporal Analysis Strategies:**

- Compare weekday vs. weekend launch performance
- Track seasonal trends across monthly leaderboards
- Identify optimal launch days through daily rank analysis
- Monitor product trajectory across daily → weekly → monthly rankings

**Competitive Intelligence:**

- Track competitor product launches and rankings
- Analyze tagline and positioning strategies of top products
- Study featured comments for user perception insights
- Monitor topic trends to identify emerging categories

**Launch Strategy Research:**

- Correlate scheduled\_at vs. featured\_at for optimal timing
- Analyze launch\_day\_score vs. latest\_score for momentum patterns
- Study comments\_count distribution for engagement benchmarks
- Compare promoted vs. organic product performance

**Category-Specific Analysis:**

- Filter by topics for vertical-specific insights
- Track category saturation and competitive intensity
- Identify underserved categories with low competition
- Monitor topic evolution and emerging subcategories

#### Common Use Cases

**For Startup Founders:**

- Research optimal launch timing and strategies
- Benchmark against competitor launches
- Identify successful tagline patterns
- Study community engagement tactics

**For Investors:**

- Track emerging startups and trending products
- Identify high-momentum products for investment pipeline
- Monitor market trends across categories
- Analyze product-market fit signals through engagement

**For Product Managers:**

- Research feature trends and product positioning
- Analyze successful launch campaigns
- Identify market gaps and opportunities
- Track competitor product evolution

**For Content Creators:**

- Identify trending products for coverage
- Track viral products for timely content
- Monitor community discussions and sentiment
- Source product review opportunities

### Benefits and Applications

**Primary Applications:**

**Launch Strategy Optimization:** Analyze successful launches to identify optimal timing, messaging, and engagement tactics. Study correlation between scheduled timing, featured positioning, and ranking success.

**Competitive Intelligence:** Track competitor product launches, monitor their ranking performance, analyze their positioning strategies, and benchmark against market leaders.

**Market Trend Analysis:** Identify emerging product categories through topic clustering, track seasonal launch patterns, monitor innovation trends across industries, and detect market opportunities.

**Investment Research:** Discover high-potential startups through ranking performance, validate market traction through vote counts and engagement, track product evolution post-launch, and identify investment opportunities early.

**Product Strategy Research:** Study successful product positioning through taglines, analyze feature trends in top-ranked products, understand community preferences through comments and voting, and identify product-market fit signals.

**Advantages:**

- Multi-period ranking data (daily/weekly/monthly) for comprehensive analysis
- Temporal tracking enables longitudinal success pattern studies
- Rich engagement metrics (votes, comments, featured status)
- Category classification through topics field
- Launch timing data for strategic optimization

The structured output integrates with analytics platforms, BI tools, and research databases, enabling immediate analysis for product strategy, competitive intelligence, and market research.

### Conclusion

The Product Hunt Leaderboard Scraper transforms manual tracking into automated intelligence gathering. By providing structured access to Product Hunt's ranking data across time periods, it enables data-driven decisions about product launches, competitive positioning, and market opportunities.

Whether you're optimizing launch strategies, tracking competitors, researching market trends, or identifying investment opportunities, this scraper delivers the systematic data extraction needed to accelerate your product intelligence.

Ready to unlock Product Hunt insights? Start extracting leaderboard data today and transform your product market intelligence.

## Your feedback

We are always working to improve Actors' performance. So, if you have any technical feedback about Product Hunt Products Listings Scraper or simply found a bug, please create an issue on the Actor's Issues tab in Apify Console.

# Actor input Schema

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

Add the URLs of the best products list page you want to scrape. You can paste URLs one by one, or use the Bulk edit section to add a prepared list.

## `ignore_url_failures` (type: `boolean`):

If true, the scraper will continue running even if some URLs fail to be scraped after the maximum number of retries is reached.

## `max_items_per_url` (type: `integer`):

Limit the number of items per URL you want to scrape

## Actor input object example

```json
{
  "urls": [
    "https://www.producthunt.com/leaderboard/daily/2026/4/9"
  ],
  "ignore_url_failures": true,
  "max_items_per_url": 20
}
```

# 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 = {
    "urls": [
        "https://www.producthunt.com/leaderboard/daily/2026/4/9"
    ],
    "ignore_url_failures": true,
    "max_items_per_url": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("ecomscrape/producthunt-leaderboard-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 = {
    "urls": ["https://www.producthunt.com/leaderboard/daily/2026/4/9"],
    "ignore_url_failures": True,
    "max_items_per_url": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("ecomscrape/producthunt-leaderboard-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 '{
  "urls": [
    "https://www.producthunt.com/leaderboard/daily/2026/4/9"
  ],
  "ignore_url_failures": true,
  "max_items_per_url": 20
}' |
apify call ecomscrape/producthunt-leaderboard-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "ProductHunt Leaderboard Scraper",
        "description": "Product Hunt Leaderboard Scraper automates extraction of trending products, rankings, votes, and launch metrics from daily, weekly, and monthly leaderboards. Efficiently collect product intelligence for competitive analysis, trend research, and market opportunity identification.",
        "version": "0.0",
        "x-build-id": "vCdCgxkC0rUaySTLP"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/ecomscrape~producthunt-leaderboard-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-ecomscrape-producthunt-leaderboard-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/ecomscrape~producthunt-leaderboard-scraper/runs": {
            "post": {
                "operationId": "runs-sync-ecomscrape-producthunt-leaderboard-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/ecomscrape~producthunt-leaderboard-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-ecomscrape-producthunt-leaderboard-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": {
                    "urls": {
                        "title": "URLs of the best products list page",
                        "type": "array",
                        "description": "Add the URLs of the best products list page you want to scrape. You can paste URLs one by one, or use the Bulk edit section to add a prepared list.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "ignore_url_failures": {
                        "title": "Ignore URL failures",
                        "type": "boolean",
                        "description": "If true, the scraper will continue running even if some URLs fail to be scraped after the maximum number of retries is reached."
                    },
                    "max_items_per_url": {
                        "title": "Limit the number of items per URL",
                        "type": "integer",
                        "description": "Limit the number of items per URL you want to scrape"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
