# Product Hunt Launch Tracker and Topic Alert Feed (`scrapemint/producthunt-launch-tracker`) Actor

Watches Product Hunt for new launches matching your topics, keywords, vote floor, and age window. Dedupes across runs. Output JSON, CSV, or Excel. For founders, VCs, and devtool marketers hunting competitor launches and category intel.

- **URL**: https://apify.com/scrapemint/producthunt-launch-tracker.md
- **Developed by:** [Kennedy Mutisya](https://apify.com/scrapemint) (community)
- **Categories:** Automation, Lead generation, E-commerce
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## 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 and Daily Launch Tracker

Watch Product Hunt for new launches that match your topics, keywords, vote floor, and age window. Export launch ID, name, tagline, full description, maker profile, vote count, comment count, topics, and timestamps. Dedupes across runs so you only ever see new launches.

Built for founders tracking competitor launches, VCs hunting early stage traction signals, devtool marketers catching category mentions, and market researchers capturing the weekly "what is new in AI" stream without scrolling Product Hunt at 9am every day.

---

### Who uses this Product Hunt scraper

```mermaid
flowchart TD
    A[Founders] -->|Watch competitor<br/>launches same-day| D[Product Hunt<br/>Launch Feed]
    B[VCs] -->|Spot traction<br/>before Series A| D
    C[Devtool marketers] -->|Reply first on<br/>category launches| D
    E[Market researchers] -->|Weekly digest of<br/>what is new| D
    D --> F[Competitor launch alerts]
    D --> G[Early stage deal flow]
    D --> H[Category intel reports]
````

| Role | What this Product Hunt scraper unlocks |
|---|---|
| **Founder** | Alert when any competitor ships, so you update your landing page before the traffic wave |
| **VC analyst** | Daily pull of every AI or devtools launch hitting 50+ votes, auto routed to your deal flow sheet |
| **Devtool marketer** | Catch launches in your category and comment first, when threads still have the most eyes |
| **Growth marketer** | Track "Show HN + Product Hunt" cross posts for weekly growth loop analysis |
| **Market researcher** | Export every launch in a topic across a year for positioning and pricing teardowns |

***

### How the Product Hunt scraper works

```mermaid
flowchart LR
    A[Topics +<br/>Keywords] --> B[Product Hunt<br/>GraphQL API]
    B --> C[Paginate cursors]
    C --> D{Filter}
    D -->|Keyword match| E[Push to dataset]
    D -->|Vote floor| E
    D -->|Age window| E
    E --> F[KV store SEEN_IDS]
    F -->|Next run| G[Skip already seen]
    G --> E
```

Pass your Product Hunt developer token, a list of topic slugs (like `artificial-intelligence`, `developer-tools`, `productivity`), and optional keyword filters. The actor calls Product Hunt's official GraphQL API, paginates cursors, filters locally by your keywords, vote count, comment count, and age, then pushes matching launches to the dataset.

Every launch ID it pushes is stored in the key value store under `SEEN_IDS`. On the next run, already seen IDs are skipped. Schedule the actor every hour and you get a deduped feed of new launches in your topics, nothing else.

Token setup is a one time thing: go to producthunt.com/v2/oauth/applications, click "Add an application", name it anything, click "Create Token", paste the long string into this actor. Tokens never expire.

***

### Product Hunt tools vs this scraper

```mermaid
flowchart LR
    subgraph Manual[Check PH by hand]
        A1[Open PH every day]
        A2[Scroll each topic]
        A3[Miss launches overnight]
    end
    subgraph Email[PH email digest]
        B1[Daily digest only]
        B2[No keyword filter]
        B3[No raw export]
    end
    subgraph Actor[This actor]
        C1[Pay per launch]
        C2[Unlimited topics]
        C3[Raw JSON, your webhooks]
    end
    Manual -.-> X[Pick a path]
    Email -.-> X
    Actor --> X
```

| Feature | PH email digest | This actor |
|---|---|---|
| Pricing | Free, limited | Pay per launch, first 30 per run free |
| Keyword filter | None | Unlimited |
| Topic targeting | Top level only | Any topic slug, any combination |
| Scheduling | Daily fixed time | Apify Scheduler every 10 minutes |
| Dedup across runs | No | Yes, in your own key value store |
| Output | Email | JSON, CSV, Excel, API, or webhook |
| Maker profiles | No | Yes, full maker object with username and headline |

***

### Quick start

Watch Product Hunt AI and devtools topics for launches that mention "agent" or "mcp", last 7 days:

```bash
curl -X POST "https://api.apify.com/v2/acts/scrapemint~producthunt-launch-tracker/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "developerToken": "YOUR_PH_DEVELOPER_TOKEN",
    "topics": ["artificial-intelligence", "developer-tools"],
    "keywords": ["agent", "mcp"],
    "sortBy": "NEWEST",
    "postedWithin": "DAY_7",
    "minVotes": 0,
    "dedupe": true
  }'
```

Track every featured launch with 100+ votes in the last 24 hours, across productivity and SaaS topics:

```json
{
  "developerToken": "YOUR_PH_DEVELOPER_TOKEN",
  "topics": ["productivity", "saas"],
  "sortBy": "VOTES",
  "postedWithin": "HOUR_24",
  "minVotes": 100,
  "featuredOnly": true
}
```

Pull every launch in the Chrome extensions topic regardless of age (one off market research):

```json
{
  "developerToken": "YOUR_PH_DEVELOPER_TOKEN",
  "topics": ["chrome-extensions"],
  "sortBy": "VOTES",
  "postedWithin": "ANY",
  "maxLaunchesPerTopic": 500,
  "dedupe": false
}
```

***

### What one launch record looks like

```json
{
  "launchId": "post_1234567",
  "name": "Relay Agents",
  "tagline": "Open source MCP server for CRM automations",
  "description": "Relay is an MCP server you run locally or on Fly that...",
  "slug": "relay-agents",
  "url": "https://www.producthunt.com/posts/relay-agents",
  "website": "https://relay.dev",
  "thumbnailUrl": "https://ph-files.imgix.net/abc123.png",
  "votesCount": 412,
  "commentsCount": 38,
  "reviewsCount": 0,
  "createdAt": "2026-04-19T07:01:00Z",
  "featuredAt": "2026-04-19T07:00:00Z",
  "topics": [
    { "name": "Artificial Intelligence", "slug": "artificial-intelligence" },
    { "name": "Developer Tools", "slug": "developer-tools" }
  ],
  "makers": [
    { "name": "Lana Chen", "username": "lanachen", "url": "https://www.producthunt.com/@lanachen", "headline": "Building Relay" }
  ],
  "matchedKeywords": ["mcp", "agent"],
  "sourceTopic": "artificial-intelligence",
  "scrapedAt": "2026-04-19T19:30:00Z"
}
```

Every row: launch ID, name, tagline, full description, slug, PH URL, maker website, thumbnail, vote count, comment count, review count, created timestamp, featured timestamp (null if not featured), topics array, makers array, and matched keywords.

***

### Pricing

First 30 launches per run are free. After that you pay per launch extracted. No seat licenses. No tier gating. A 200 launch run lands under $1 on the Apify free plan.

***

### FAQ

**Do I need a Product Hunt account?**
Yes, a free one. You need a developer token, which is made in 30 seconds at producthunt.com/v2/oauth/applications. Tokens do not expire and do not count against any paid tier.

**Can I track all of Product Hunt, not just specific topics?**
Yes. Leave `topics` empty and the actor queries the global posts feed.

**Does it return maker profiles?**
Yes. Each launch record includes a `makers` array with each maker's username, URL, headline, and Product Hunt ID. Useful for founder outreach and VC deal flow.

**Does it return product descriptions?**
Yes. The full long form description is in the `description` field, not just the tagline. The `tagline` is the one line pitch on the card. Both are searchable by your keyword filter.

**How fresh is the data?**
Product Hunt's GraphQL API updates in real time. Launches appear in the API the moment they post, even before they hit the homepage.

**Does it dedupe?**
Yes. Launch IDs are stored in the key value store under `SEEN_IDS`. Every run skips IDs already seen. Set `dedupe: false` to disable.

**What are some useful topic slugs?**
`artificial-intelligence`, `developer-tools`, `productivity`, `saas`, `marketing`, `design-tools`, `chrome-extensions`, `no-code`, `fintech`, `e-commerce`. Find any topic slug by opening its page on Product Hunt, the URL ends with the slug.

**Can I use this for VC deal flow?**
Yes. Filter by `minVotes: 50` and `postedWithin: DAY_7`, schedule weekly, pipe the webhook into Airtable or Notion. Every launch with early traction in your thesis topics hits your pipeline without a scraping intern.

***

### Related actors by Scrapemint

- **Hacker News Scraper** for stories and comments matching keywords
- **Reddit Lead Monitor** for subreddit and keyword mention tracking
- **Upwork Opportunity Alert** for freelance lead generation
- **App Store Review Scraper** for mobile apps on iOS and Android
- **Trustpilot Brand Reputation** for DTC and ecommerce brands
- **Google Reviews Intelligence** for local businesses
- **Amazon Review Intelligence** for product reviews and listings
- **Indeed Company Review Intelligence** for employer branding

Stack these to cover every public launch and conversation surface one brand touches.

# Actor input Schema

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

Create a free developer token at https://www.producthunt.com/v2/oauth/applications. Click 'Add an application', name it, click 'Create Token', and paste the long string here. Tokens do not expire.

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

Product Hunt topic slugs. Example: artificial-intelligence, developer-tools, productivity, saas, marketing, design-tools, chrome-extensions. Find slugs in the URL of any topic page. Leave empty to watch all of Product Hunt.

## `keywords` (type: `array`):

Only launches whose name, tagline, or description contains any of these keywords are kept. Case insensitive. Leave empty to keep all launches in your topics.

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

NEWEST returns the latest submissions. VOTES ranks by upvotes. RANKING uses Product Hunt's daily ranking. FEATURED\_AT orders by when the post was featured on the homepage.

## `postedWithin` (type: `string`):

Only return launches posted within this window.

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

Skip launches with fewer than this many upvotes. 0 keeps everything including brand new posts.

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

Skip launches with fewer than this many comments. 0 keeps everything.

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

Keep only launches that were featured on the Product Hunt homepage. Featured posts have moderator approval and a featuredAt timestamp.

## `maxLaunchesPerTopic` (type: `integer`):

Per topic cap. Product Hunt pagination returns up to 20 posts per page, the actor paginates until this cap or the end of the topic feed.

## `maxLaunchesTotal` (type: `integer`):

Hard cap on launches pushed to the dataset per run. Controls cost.

## `dedupe` (type: `boolean`):

Skip launch IDs already pushed on previous runs. IDs are stored in the key value store under SEEN\_IDS. Turn off to return every match on every run.

## `proxyConfiguration` (type: `object`):

Apify proxy settings. The Product Hunt GraphQL API is fully accessible without a proxy in most cases.

## Actor input object example

```json
{
  "topics": [
    "artificial-intelligence",
    "developer-tools"
  ],
  "sortBy": "NEWEST",
  "postedWithin": "DAY_7",
  "minVotes": 0,
  "minComments": 0,
  "featuredOnly": false,
  "maxLaunchesPerTopic": 100,
  "maxLaunchesTotal": 200,
  "dedupe": true
}
```

# 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 = {
    "topics": [
        "artificial-intelligence",
        "developer-tools"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapemint/producthunt-launch-tracker").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 = { "topics": [
        "artificial-intelligence",
        "developer-tools",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("scrapemint/producthunt-launch-tracker").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 '{
  "topics": [
    "artificial-intelligence",
    "developer-tools"
  ]
}' |
apify call scrapemint/producthunt-launch-tracker --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Product Hunt Launch Tracker and Topic Alert Feed",
        "description": "Watches Product Hunt for new launches matching your topics, keywords, vote floor, and age window. Dedupes across runs. Output JSON, CSV, or Excel. For founders, VCs, and devtool marketers hunting competitor launches and category intel.",
        "version": "0.1",
        "x-build-id": "cKrgd7T9gjFqyBsMh"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapemint~producthunt-launch-tracker/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapemint-producthunt-launch-tracker",
                "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/scrapemint~producthunt-launch-tracker/runs": {
            "post": {
                "operationId": "runs-sync-scrapemint-producthunt-launch-tracker",
                "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/scrapemint~producthunt-launch-tracker/run-sync": {
            "post": {
                "operationId": "run-sync-scrapemint-producthunt-launch-tracker",
                "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": [
                    "developerToken"
                ],
                "properties": {
                    "developerToken": {
                        "title": "Product Hunt developer token (required)",
                        "type": "string",
                        "description": "Create a free developer token at https://www.producthunt.com/v2/oauth/applications. Click 'Add an application', name it, click 'Create Token', and paste the long string here. Tokens do not expire."
                    },
                    "topics": {
                        "title": "Topic slugs to watch",
                        "type": "array",
                        "description": "Product Hunt topic slugs. Example: artificial-intelligence, developer-tools, productivity, saas, marketing, design-tools, chrome-extensions. Find slugs in the URL of any topic page. Leave empty to watch all of Product Hunt.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "keywords": {
                        "title": "Keywords (client side filter)",
                        "type": "array",
                        "description": "Only launches whose name, tagline, or description contains any of these keywords are kept. Case insensitive. Leave empty to keep all launches in your topics.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "sortBy": {
                        "title": "Sort",
                        "enum": [
                            "NEWEST",
                            "VOTES",
                            "RANKING",
                            "FEATURED_AT"
                        ],
                        "type": "string",
                        "description": "NEWEST returns the latest submissions. VOTES ranks by upvotes. RANKING uses Product Hunt's daily ranking. FEATURED_AT orders by when the post was featured on the homepage.",
                        "default": "NEWEST"
                    },
                    "postedWithin": {
                        "title": "Posted within",
                        "enum": [
                            "HOUR_24",
                            "DAY_7",
                            "DAY_30",
                            "ANY"
                        ],
                        "type": "string",
                        "description": "Only return launches posted within this window.",
                        "default": "DAY_7"
                    },
                    "minVotes": {
                        "title": "Minimum upvotes",
                        "minimum": 0,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Skip launches with fewer than this many upvotes. 0 keeps everything including brand new posts.",
                        "default": 0
                    },
                    "minComments": {
                        "title": "Minimum comments",
                        "minimum": 0,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Skip launches with fewer than this many comments. 0 keeps everything.",
                        "default": 0
                    },
                    "featuredOnly": {
                        "title": "Featured launches only",
                        "type": "boolean",
                        "description": "Keep only launches that were featured on the Product Hunt homepage. Featured posts have moderator approval and a featuredAt timestamp.",
                        "default": false
                    },
                    "maxLaunchesPerTopic": {
                        "title": "Max launches per topic",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Per topic cap. Product Hunt pagination returns up to 20 posts per page, the actor paginates until this cap or the end of the topic feed.",
                        "default": 100
                    },
                    "maxLaunchesTotal": {
                        "title": "Maximum launches per run",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Hard cap on launches pushed to the dataset per run. Controls cost.",
                        "default": 200
                    },
                    "dedupe": {
                        "title": "Deduplicate across runs",
                        "type": "boolean",
                        "description": "Skip launch IDs already pushed on previous runs. IDs are stored in the key value store under SEEN_IDS. Turn off to return every match on every run.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify proxy settings. The Product Hunt GraphQL API is fully accessible without a proxy in most cases."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```