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

Extract Product Hunt posts from search pages, topic pages, today launches, or direct URLs. Get structured data with product name, tagline, votes, featured flag, topics, makers, Product Hunt link, website link, source URL, and scrape timestamp for research and tracking workflows.

- **URL**: https://apify.com/parseforge/producthunt-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Automation, Developer tools, Other
- **Stats:** 6 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 🚀 Product Hunt Scraper

> 🚀 **Export daily Product Hunt launches with votes, comments, and maker info in seconds.** No API key, no account, no scraping setup.

> 🕒 **Last updated:** 2026-05-22 · **📊 12 fields** per record · **Up to 20 launches per day** · **Covers up to 30 days back**

The **Product Hunt Scraper** pulls live daily product launch data directly from Product Hunt's leaderboard pages - the same data powering the site's own rankings. Every run returns fresh results: product names, taglines, descriptions, vote counts, comment counts, topic tags, maker names, and thumbnail images. No Playwright, no browser - pure HTTP with browser-like fingerprinting.

Product Hunt publishes a ranked daily leaderboard of every product submitted that day. This actor makes that data downloadable as CSV, Excel, JSON, or XML in under a minute. Monitor the startup ecosystem, track AI tool launches, or build a daily digest - all without writing a single line of code.

**Coverage:** Up to 20 ranked posts per day, up to 30 days back. Vote counts (`votesCount`) reflect the score at launch day. All fields are scraped in real-time on every run.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Startup founders, VCs, product managers, tech journalists, marketers, researchers, indie hackers | Daily launch monitoring, competitor tracking, AI tool discovery, trend analysis, content pipelines |

---

### 📋 What the Product Hunt Scraper does

- Fetches the daily leaderboard page for each requested day (up to 30 days back)
- Extracts all ranked product launches with name, tagline, topics, vote score, and comment count
- Follows each post's detail page to extract the full description and maker name
- Filters out promoted ad slots so only organic launches appear in your dataset
- Caps output at your requested `maxItems` and free-tier limit
- Pushes structured JSON records to the Apify dataset - ready for CSV, Excel, or API export

> 💡 **Why it matters:** Product Hunt is the launchpad for thousands of new tools every year - from AI agents to SaaS to developer tools. Monitoring launches manually is time-consuming. This actor gives you structured data you can query, filter, and pipe into any workflow.

---

### 🎬 Full Demo

🚧 Coming soon - video walkthrough of a full daily-launches run with CSV export.

---

### ⚙️ Input

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `daysBack` | number | `1` | Number of past days to fetch launches for. 1 = today only, 7 = last week. Max 30. |
| `maxItems` | number | `10` | Maximum number of launches to return. Free plan caps at 10, paid plan at 1,000,000. |

#### Example - Today's top 20 launches

```json
{
  "daysBack": 1,
  "maxItems": 20
}
````

#### Example - Last week of launches (up to 140 products)

```json
{
  "daysBack": 7,
  "maxItems": 140
}
```

> ⚠️ **Good to Know:** Product Hunt uses Pacific Time (UTC-7) for its daily leaderboards. The actor automatically adjusts dates to match. Each launch requires 2 HTTP requests (leaderboard page + detail page), so large `maxItems` values take proportionally longer. A run of 20 items typically completes in under 30 seconds.

***

### 📊 Output

Each record contains these fields:

| Field | Type | Description |
|-------|------|-------------|
| 🖼 `imageUrl` | string | Thumbnail image URL (hosted on ph-files.imgix.net) |
| 📛 `name` | string | Product name |
| 💬 `tagline` | string | One-line tagline |
| 📝 `description` | string | Full product description from the post page |
| 🔗 `url` | string | Direct link to the Product Hunt post |
| 👍 `votesCount` | integer | Launch day vote score |
| 💬 `commentsCount` | integer | Number of comments at scrape time |
| 🏷 `topics` | array | Topic tags (e.g. \["Artificial Intelligence", "Developer Tools"]) |
| 👤 `maker` | string | Name of the product's primary maker |
| 📅 `createdAt` | string | ISO 8601 timestamp of launch date |
| 📅 `featuredAt` | string | ISO 8601 timestamp when the product was featured |
| 🕒 `scrapedAt` | string | ISO 8601 timestamp of this scrape |
| ❌ `error` | string | Error message if item failed to load, otherwise absent |

#### Sample records (real data from 2026-05-21)

```json
[
  {
    "imageUrl": "https://ph-files.imgix.net/8148cb1b-0da3-4574-9f71-08798b552316.svg?auto=format&fit=max&w=200",
    "name": "Tycoon AI",
    "tagline": "Run one-person companies entirely with AI agents",
    "description": "Tycoon.us enables you to run an entire company with AI agents, powered by Astra, an AI CEO, and 10+ ready-to-use AI agents you can choose from, from CMO who manages X to CTO who codes.",
    "url": "https://www.producthunt.com/posts/tycoon-ai",
    "votesCount": 391,
    "commentsCount": 88,
    "topics": ["Marketing", "Artificial Intelligence", "Tech"],
    "maker": "Richie Cheng",
    "createdAt": "2026-05-21T00:01:00-07:00",
    "featuredAt": "2026-05-21T00:01:00-07:00",
    "scrapedAt": "2026-05-22T03:14:34.059Z"
  },
  {
    "imageUrl": "https://ph-files.imgix.net/5daa9b0c-dec8-45be-856c-36a7e4957c32.png?auto=format&fit=max&w=200",
    "name": "Mintlify Workflows",
    "tagline": "Self-updating knowledge bases",
    "description": "The next generation of documentation. AI-native, beautiful out-of-the-box, and built for collaboration.",
    "url": "https://www.producthunt.com/posts/mintlify-workflows-2",
    "votesCount": 272,
    "commentsCount": 35,
    "topics": ["Notes", "Developer Tools", "Artificial Intelligence"],
    "maker": "Neha Halebeed",
    "createdAt": "2026-05-21T00:01:00-07:00",
    "featuredAt": "2026-05-21T00:01:00-07:00",
    "scrapedAt": "2026-05-22T03:14:34.059Z"
  },
  {
    "imageUrl": "https://ph-files.imgix.net/63f91d11-901f-4ea3-88e2-a60dc4764fe1.webp?auto=format&fit=max&w=200",
    "name": "WeWeb 3.0",
    "tagline": "Vibe-code apps with the safety net of a no-code editor",
    "description": "Most AI builders get you 80% of the way there. WeWeb helps you finish the job. Use AI to generate apps, then customize everything yourself in a powerful no-code editor.",
    "url": "https://www.producthunt.com/posts/weweb-3-0",
    "votesCount": 244,
    "commentsCount": 70,
    "topics": ["Website Builder", "Artificial Intelligence", "No-Code"],
    "maker": "Joyce Kettering",
    "createdAt": "2026-05-21T00:01:00-07:00",
    "featuredAt": "2026-05-21T00:01:00-07:00",
    "scrapedAt": "2026-05-22T03:14:35.628Z"
  }
]
```

***

### ✨ Why choose this Actor

| Feature | Details |
|---------|---------|
| 🖼 **Thumbnail images** | Full-res product images via Product Hunt's CDN |
| 📝 **Full descriptions** | Complete product description from the post page, not just the tagline |
| 👤 **Maker info** | Primary maker name extracted from each post |
| 🏷 **Topic tags** | All topic/category tags per product |
| 📅 **Date-range support** | Fetch up to 30 days back in a single run |
| 🧹 **Ad filtering** | Promoted ad slots automatically excluded |
| 🆓 **Free tier** | 10 launches free, no account required |
| ⚡ **Fast** | 20 items in under 30 seconds |

***

### 📈 How it compares to alternatives

| Feature | This Actor | Manual browsing | Product Hunt API v2 |
|---------|-----------|-----------------|---------------------|
| No auth required | ✅ | ✅ | OAuth required |
| Full descriptions | ✅ | ✅ | ✅ |
| Maker names | ✅ | ✅ | ✅ |
| Multi-day range | ✅ | Manual | ✅ |
| Structured JSON output | ✅ | - | ✅ |
| CSV / Excel export | ✅ | - | Manual |
| Cloud scheduling | ✅ | - | Custom code |
| Zero setup | ✅ | ✅ | Developer setup |

***

### 🚀 How to use

1. [Create a free Apify account](https://console.apify.com/sign-up?fpr=vmoqkp) - includes $5 credit
2. Open the **Product Hunt Scraper** actor page on Apify Store
3. Set **Days Back** (1 for today, 7 for last week, up to 30)
4. Set **Max Items** (10 for a preview, 20 for a full day, 140+ for a week)
5. Click **Start** and wait 10-30 seconds
6. Download your dataset as JSON, CSV, Excel, or XML

***

### 💼 Business use cases

#### 1. Daily Launch Monitoring

Track every product that launches on Product Hunt each day. Schedule a daily run and pipe results to Slack, Notion, or a Google Sheet. Know instantly when competitors or adjacent tools launch - before you see it on social media.

#### 2. AI Tool Discovery

Product Hunt is ground zero for AI tool launches. Filter the `topics` array for "Artificial Intelligence" records and build a live feed of every new AI product. Use it to populate a newsletter, competitive analysis doc, or an internal knowledge base.

#### 3. Trend Analysis

Run weekly pulls for 30 days and aggregate `votesCount` by topic. Spot which categories are gaining traction - AI agents, no-code tools, developer infrastructure - before they make the tech press. Use `createdAt` to build time-series charts.

#### 4. Startup Research

VCs, accelerators, and angels monitor Product Hunt for deal flow. Combine this actor with a filtering workflow to surface only products in your target sectors. Add maker names to your CRM automatically using a Make or Zapier scenario.

***

### 🔌 Automating Product Hunt Scraper

Connect this actor to your favorite automation tools:

- **Make (Integromat)**: Schedule daily runs and push new launches to Google Sheets, Airtable, or Notion
- **Zapier**: Trigger on new dataset items and post product names to Slack or Discord
- **Apify Scheduler**: Run every morning to get the previous day's complete leaderboard
- **Apify API**: Call programmatically from any language using the REST API
- **Webhooks**: Get notified when a run completes and process results in your own backend

***

### 🌟 Beyond business use cases

#### Research

Study launch patterns, vote dynamics, and topic popularity over time. Product Hunt's daily structure makes it ideal for longitudinal datasets on the startup ecosystem.

#### Creative Projects

Build a personal "Product Hunt digest" page or browser extension. Power a daily email with the top 5 launches in a category you care about - automatically curated, zero manual work.

#### Non-Profit and Open Source

Track launches of open source projects, public-interest tech tools, or accessibility software. Build visibility reports to demonstrate community interest in mission-driven products.

#### Experimentation

Test hypotheses about what makes a product successful on launch day. Does having more topics correlate with more votes? Do certain makers consistently hit the top 3? Build ML features from this data.

***

### 🤖 Ask an AI assistant about this scraper

Not sure if this actor fits your use case? Drop this into ChatGPT, Claude, or Gemini:

> "I want to monitor Product Hunt daily launches and export them to a spreadsheet. The actor is called Product Hunt Scraper by ParseForge on Apify. It outputs fields like name, tagline, description, url, votesCount, commentsCount, topics, maker, imageUrl, createdAt, and featuredAt. Can you write me a Make scenario or Zapier workflow to automate this?"

***

### ❓ Frequently Asked Questions

#### ❓ Does it require a Product Hunt account or API key?

No. The actor scrapes the public leaderboard pages directly. No authentication, no registration, no API key.

#### ❓ How many products launch on Product Hunt each day?

Typically 15-25 products are featured on the daily leaderboard. The actor returns all of them (up to your `maxItems` limit).

#### ❓ What does `votesCount` represent?

It is the launch day vote score - the number of upvotes received during the product's launch day on Product Hunt.

#### ❓ Can I get historical launches from months or years ago?

Yes - the leaderboard pages exist for any past date. The actor supports up to 30 days back per run. For older history, run the actor multiple times with different start dates or use Apify scheduling to build your own archive.

#### ❓ Why does `daysBack: 1` sometimes return yesterday's results?

Product Hunt uses Pacific Time (UTC-7). If you run the actor before midnight Pacific, "today" has no leaderboard yet, so the actor returns the previous day's launches. This is expected behavior.

#### ❓ Are promoted/sponsored products included?

No. Ad slots are automatically filtered out. Only organic product launches appear in your dataset.

#### ❓ How accurate is the maker name?

The actor extracts the primary maker from the post page's structured data. Products with multiple makers return only the first listed maker.

#### ❓ How fast does the scraper run?

A 20-item run (one day) typically completes in 20-30 seconds. Each item requires 2 HTTP requests. A 7-day run with `maxItems: 140` takes approximately 2-3 minutes.

#### ❓ Can I schedule this to run automatically?

Yes. Use the Apify Scheduler to set up daily runs and always have fresh launch data without manual effort.

#### ❓ What happens if Product Hunt changes their page structure?

The actor uses the Apollo SSR data embedded in the page's HTML, which is more stable than CSS selectors. If the structure changes, the ParseForge team will update the actor.

#### ❓ Does it work with the Apify API?

Yes. Every run creates a dataset accessible via the Apify REST API. You can poll for results, stream items, or integrate with Python, Node.js, or any HTTP client.

***

### 🔌 Integrate with any app

Export your dataset in any format and connect it to the tools you already use:

**Spreadsheets:** Google Sheets, Microsoft Excel, LibreOffice Calc

**Databases:** PostgreSQL, MySQL, MongoDB, Airtable, Notion

**BI Tools:** Tableau, Power BI, Metabase, Grafana

**Automation:** Make, Zapier, n8n, Activepieces

**Cloud Storage:** Google Drive, Dropbox, AWS S3

**Communication:** Slack, Discord, Microsoft Teams (via webhook)

**Code:** REST API, Python, Node.js, Ruby, PHP

***

### 🔗 Recommended Actors

| Actor | Description |
|-------|-------------|
| [Hacker News Scraper](https://apify.com/parseforge/hacker-news-scraper) | Export top, new, best, Ask HN, and Show HN stories with scores and metadata |
| [GitHub Trending Scraper](https://apify.com/parseforge/github-trending-scraper) | Export trending repositories by language and time period |
| [Dev.to Scraper](https://apify.com/parseforge/dev-to-scraper) | Scrape articles, tags, and author data from Dev.to |

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for scrapers covering 100+ websites across tech, finance, jobs, and more.

***

*This actor scrapes publicly available data from producthunt.com. It is not affiliated with or endorsed by Product Hunt or its parent company. Use responsibly and in accordance with Product Hunt's terms of service.*

# Actor input Schema

## `daysBack` (type: `integer`):

Number of past days to fetch product launches for (1 = today only, 7 = last week). Max 30.

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

## Actor input object example

```json
{
  "daysBack": 1,
  "maxItems": 10
}
```

# 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 = {
    "daysBack": 1,
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/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 = {
    "daysBack": 1,
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/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 '{
  "daysBack": 1,
  "maxItems": 10
}' |
apify call parseforge/producthunt-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Product Hunt Scraper",
        "description": "Extract Product Hunt posts from search pages, topic pages, today launches, or direct URLs. Get structured data with product name, tagline, votes, featured flag, topics, makers, Product Hunt link, website link, source URL, and scrape timestamp for research and tracking workflows.",
        "version": "0.1",
        "x-build-id": "0nLAEnKLF2u8JtKin"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~producthunt-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-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/parseforge~producthunt-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-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/parseforge~producthunt-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-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",
                "properties": {
                    "daysBack": {
                        "title": "Days Back",
                        "minimum": 1,
                        "maximum": 30,
                        "type": "integer",
                        "description": "Number of past days to fetch product launches for (1 = today only, 7 = last week). Max 30."
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
