# PromptBase Scraper (`automation-lab/promptbase-scraper`) Actor

Scrape PromptBase marketplace for AI prompt listings. Extract title, price, AI model type, seller info, ratings, reviews, and tags. Supports keyword search, category browse, and sort by trending/newest. Export to JSON, CSV, or Excel.

- **URL**: https://apify.com/automation-lab/promptbase-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** AI, E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN 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

## PromptBase Scraper

### What does PromptBase Scraper do?

**PromptBase Scraper** extracts prompt listings from [PromptBase](https://promptbase.com) — the largest AI prompt marketplace with 100,000+ listings. It collects **title, price, AI model type, seller info, ratings, reviews, favorites, views, word count, and tags** from any search, category, or trending page. No login or API key required.

The scraper works by browsing PromptBase's marketplace pages and extracting structured data from each prompt listing. You can optionally visit each prompt's detail page for enriched data including full descriptions, seller profiles, and engagement metrics.

Try it now — enter a search query like "logo design" and get structured data in seconds.

### Who is PromptBase Scraper for?

🎯 **Prompt engineers and sellers**
- Research what types of prompts sell best and at what price points
- Analyze competitor prompts in your niche before creating new listings
- Track trending prompt categories and pricing strategies

📊 **AI researchers and analysts**
- Study the economics of the prompt marketplace
- Track which AI models have the most demand (ChatGPT, Midjourney, DALL-E, etc.)
- Build datasets for academic research on the AI prompt economy

🏢 **AI startups and product teams**
- Identify popular use cases and prompt categories for product roadmaps
- Monitor the competitive landscape of AI content tools
- Source inspiration for AI-powered features

📈 **Marketing and content agencies**
- Discover trending AI content themes and styles
- Research pricing benchmarks for AI-generated content services
- Build prompt libraries for internal team use

### Why use PromptBase Scraper?

- 🔍 **No competitors on Apify Store** — this is the only PromptBase scraper available
- 🚫 **No login required** — scrapes publicly available marketplace data
- ⚡ **Fast extraction** — scrape 50+ prompt listings in under a minute
- 📄 **Rich data** — get title, price, model type, seller, ratings, reviews, views, and more
- 🔄 **Multiple modes** — search by keyword, browse by AI model category, or sort by trending/newest/popular
- 📊 **Export anywhere** — JSON, CSV, Excel, or integrate with 5,000+ apps via Zapier and Make
- 🤖 **API access** — automate prompt research with the Apify API
- 📅 **Schedule runs** — set up daily or weekly monitoring of trending prompts

### What data can you extract?

| Field | Description | Source |
|-------|-------------|--------|
| 📝 `title` | Prompt listing title | Listing + Detail |
| 📄 `description` | Full prompt description and features | Detail page |
| 💰 `price` | Current price in USD (0 for free prompts) | Listing + Detail |
| 🤖 `modelType` | AI model (Midjourney, ChatGPT, DALL-E, etc.) | Listing + Detail |
| 👤 `seller` | Seller username | Detail page |
| 🔗 `sellerUrl` | Link to seller's profile page | Detail page |
| ⭐ `rating` | Average star rating (1-5) | Listing + Detail |
| 💬 `reviewCount` | Number of reviews | Detail page |
| ❤️ `favorites` | Number of users who favorited | Detail page |
| 👁️ `views` | Total views on the listing | Detail page |
| 🏷️ `tags` | Tags and labels | Detail page |
| 🖼️ `thumbnail` | Thumbnail image URL | Listing |
| 🔗 `url` | Direct link to the prompt page | Listing |
| 📏 `wordCount` | Prompt word count | Detail page |
| 📖 `hasGuide` | Whether a usage guide is included | Detail page |
| 📎 `exampleCount` | Number of example outputs | Detail page |
| 🕐 `scrapedAt` | Timestamp of when data was collected | Auto |

### How much does it cost to scrape PromptBase?

PromptBase Scraper uses **pay-per-event pricing** — you only pay for what you scrape.

| Event | Price (Free tier) | Description |
|-------|-------------------|-------------|
| Run started | $0.035 | One-time charge per run |
| Prompt scraped | $0.004 | Per prompt listing extracted |

**Example costs:**
- 🆓 **Free plan ($5 credits):** ~1,200 prompts per month
- 📊 **50 prompts** = $0.035 + (50 × $0.004) = **$0.24**
- 📦 **200 prompts** = $0.035 + (200 × $0.004) = **$0.84**
- 🏭 **500 prompts** = $0.035 + (500 × $0.004) = **$2.04**

Higher subscription tiers get automatic volume discounts — up to 54% off on the Diamond plan.

### How to scrape PromptBase prompts

1. Go to the [PromptBase Scraper](https://apify.com/automation-lab/promptbase-scraper) page on Apify Store
2. Click **Try for free** to open the actor in Apify Console
3. Enter your **search query** (e.g., "logo design") or select an **AI model category** (e.g., Midjourney)
4. Set the **max prompts** to control how many results to scrape
5. Toggle **Include detail pages** if you want full descriptions, reviews, and seller info
6. Click **Start** and wait for the run to complete
7. Download your data as JSON, CSV, or Excel from the **Dataset** tab

**Example input for keyword search:**
```json
{
    "searchQuery": "logo design",
    "maxPrompts": 50,
    "includeDetails": true
}
````

**Example input for category browse:**

```json
{
    "category": "midjourney",
    "sortBy": "hotness",
    "maxPrompts": 100,
    "includeDetails": false
}
```

**Example input for newest prompts:**

```json
{
    "sortBy": "created",
    "maxPrompts": 30,
    "includeDetails": true
}
```

### Input parameters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `searchQuery` | string | — | Search for prompts by keyword |
| `category` | string | (all) | Filter by AI model: chatgpt, midjourney, dall-e, stable-diffusion, claude, gemini, flux, llama |
| `sortBy` | string | hotness | Sort order: hotness (trending), created (newest), score (most popular) |
| `maxPrompts` | integer | 50 | Maximum number of prompts to scrape (1-500) |
| `includeDetails` | boolean | true | Visit each prompt's detail page for full data |
| `proxyConfiguration` | object | Apify Proxy | Proxy settings for the browser |

### Output example

```json
{
    "title": "Dark Futuristic Tarot Cards",
    "description": "CREATE. INSPIRE. STAND OUT. EXCLUSIVE PROMO: Get a prompt, leave a 5-star review + like, and receive an extra prompt for free...",
    "price": 3.99,
    "currency": "USD",
    "modelType": "Gemini Image",
    "seller": "emanema",
    "sellerUrl": "https://promptbase.com/profile/emanema",
    "rating": 5,
    "reviewCount": 1,
    "favorites": 2,
    "views": 61,
    "tags": ["3.1-FLASH-IMAGE"],
    "thumbnail": "https://assets.promptbase.com/Thumbnails/...",
    "url": "https://promptbase.com/prompt/dark-gothic-tarot-cards",
    "wordCount": 32,
    "hasGuide": false,
    "exampleCount": null,
    "scrapedAt": "2026-04-20T08:31:16.114Z"
}
```

### Tips for best results

- 🎯 **Start small** — set `maxPrompts` to 10-20 for your first run to preview the data before scaling up
- ⚡ **Skip detail pages for speed** — set `includeDetails: false` to scrape 5x faster (listing data only)
- 🔍 **Use specific search queries** — "minimalist logo design" finds better results than just "logo"
- 📊 **Combine search + sort** — search for a keyword and sort by "score" to find the most popular prompts in that niche
- 📅 **Schedule weekly runs** — monitor trending prompts in your niche with scheduled runs
- 💰 **Free prompts too** — the scraper captures free prompts (price = 0) alongside paid listings
- 🏷️ **Browse by category** — use the `category` filter to explore all prompts for a specific AI model

### Integrations

📊 **PromptBase Scraper → Google Sheets**
Export prompt data to a Google Sheet for price analysis and trend tracking. Set up a scheduled run to automatically update your sheet with new trending prompts every day.

💬 **PromptBase Scraper → Slack/Discord**
Get notified when new prompts appear in your niche. Set up a webhook to alert your team about trending prompt categories or price drops.

🔄 **PromptBase Scraper → Make/Zapier**
Build automated workflows: scrape trending prompts → filter by price range → save to Airtable → send weekly digest email to your team.

📅 **Scheduled monitoring**
Run the scraper daily to track pricing trends, new prompt categories, and seller activity. Compare snapshots over time to identify market shifts.

🔗 **Webhook processing**
Use Apify webhooks to trigger downstream processing whenever a scrape completes — feed data into your analytics pipeline, CRM, or custom dashboard.

### Using the Apify API

You can run PromptBase Scraper programmatically using the Apify API.

#### Node.js

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });

const run = await client.actor('automation-lab/promptbase-scraper').call({
    searchQuery: 'logo design',
    maxPrompts: 50,
    includeDetails: true,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')

run = client.actor('automation-lab/promptbase-scraper').call(run_input={
    'searchQuery': 'logo design',
    'maxPrompts': 50,
    'includeDetails': True,
})

items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~promptbase-scraper/runs?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "searchQuery": "logo design",
    "maxPrompts": 50,
    "includeDetails": true
  }'
```

### Use with AI agents via MCP

PromptBase Scraper is available as a tool for AI assistants that support the [Model Context Protocol (MCP)](https://docs.apify.com/platform/integrations/mcp).

Add the Apify MCP server to your AI client — this gives you access to all Apify actors, including this one:

#### Setup for Claude Code

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/promptbase-scraper"
```

#### Setup for Claude Desktop, Cursor, or VS Code

Add this to your MCP config file:

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com?tools=automation-lab/promptbase-scraper",
            "headers": {
                "Authorization": "Bearer YOUR_APIFY_TOKEN"
            }
        }
    }
}
```

#### Example prompts

- "Scrape the top 20 trending Midjourney prompts from PromptBase and show me their prices"
- "Find all ChatGPT prompts about marketing on PromptBase and export them to a spreadsheet"
- "What are the most popular AI prompt categories on PromptBase right now?"

### Is it legal to scrape PromptBase?

PromptBase Scraper only extracts publicly available data from the PromptBase marketplace. It does not bypass any authentication, access private user data, or download actual prompt content (only metadata like titles, prices, and descriptions).

Web scraping of public data is generally legal, as confirmed by the [US Court of Appeals ruling in hiQ Labs v. LinkedIn](https://en.wikipedia.org/wiki/HiQ_Labs_v._LinkedIn). However, you should always review and comply with the target website's terms of service and applicable data protection regulations (GDPR, CCPA) before scraping.

For more information, see Apify's guide on [web scraping legality](https://blog.apify.com/is-web-scraping-legal/).

### FAQ

**How fast is PromptBase Scraper?**
Without detail pages, the scraper extracts 30-50 prompts per page load (2-5 seconds). With detail pages enabled, each prompt takes an additional 1-2 seconds. A typical run of 50 prompts with details completes in about 2 minutes.

**How much does it cost to scrape 100 prompts?**
About $0.44 on the Free tier ($0.035 start + 100 × $0.004 per prompt). Higher subscription tiers get volume discounts.

**Does this scraper download the actual prompts?**
No. PromptBase Scraper only extracts publicly visible metadata — titles, prices, descriptions, ratings, and seller info. The actual prompt text that buyers pay for is not accessible without purchase.

**Why are some fields null in the output?**
Fields like `rating`, `reviewCount`, `favorites`, and `views` may be null when scraping without detail pages (`includeDetails: false`), or when a prompt is too new to have engagement data. Enable detail pages for the most complete data.

**Why do I get different results than expected for my search?**
PromptBase's search results are influenced by trending algorithms and seller boosting. The same search query may return different results on different days. Use `sortBy: "created"` for chronological results.

### Other AI and data scrapers

- 🤖 [AI Tools Directory Scraper](https://apify.com/automation-lab/ai-tools-directory-scraper) — Scrape Futurepedia and Toolify.ai for AI tool listings
- 📱 [TikTok Scraper](https://apify.com/automation-lab/tiktok-scraper) — Extract TikTok videos, profiles, and trending content
- 🐦 [Bluesky Scraper](https://apify.com/automation-lab/bluesky-scraper) — Scrape posts and profiles from Bluesky
- 🛒 [Amazon Scraper](https://apify.com/automation-lab/amazon-scraper) — Extract product data from Amazon
- ⭐ [Google Reviews Scraper](https://apify.com/automation-lab/google-reviews-scraper) — Collect Google Maps reviews

# Actor input Schema

## `searchQuery` (type: `string`):

Search for prompts by keyword. Leave empty to browse by category.

## `category` (type: `string`):

Filter prompts by AI model. Only used when search query is empty.

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

Sort results by trending, newest, or popularity.

## `maxPrompts` (type: `integer`):

Maximum number of prompt listings to scrape.

## `includeDetails` (type: `boolean`):

Visit each prompt's detail page for full description, reviews, and seller info. Slower but more data.

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

Select proxies for the actor. Datacenter proxies usually work fine.

## Actor input object example

```json
{
  "searchQuery": "logo design",
  "category": "",
  "sortBy": "hotness",
  "maxPrompts": 10,
  "includeDetails": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# 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 = {
    "searchQuery": "logo design",
    "maxPrompts": 10,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/promptbase-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 = {
    "searchQuery": "logo design",
    "maxPrompts": 10,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/promptbase-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 '{
  "searchQuery": "logo design",
  "maxPrompts": 10,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call automation-lab/promptbase-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "PromptBase Scraper",
        "description": "Scrape PromptBase marketplace for AI prompt listings. Extract title, price, AI model type, seller info, ratings, reviews, and tags. Supports keyword search, category browse, and sort by trending/newest. Export to JSON, CSV, or Excel.",
        "version": "0.1",
        "x-build-id": "EZ46mIqpv3UbIe7S9"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~promptbase-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-promptbase-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/automation-lab~promptbase-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-promptbase-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/automation-lab~promptbase-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-promptbase-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": {
                    "searchQuery": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Search for prompts by keyword. Leave empty to browse by category."
                    },
                    "category": {
                        "title": "AI model category",
                        "enum": [
                            "",
                            "chatgpt",
                            "gpt-4",
                            "dall-e",
                            "midjourney",
                            "stable-diffusion",
                            "claude",
                            "gemini",
                            "llama",
                            "flux"
                        ],
                        "type": "string",
                        "description": "Filter prompts by AI model. Only used when search query is empty.",
                        "default": ""
                    },
                    "sortBy": {
                        "title": "Sort order",
                        "enum": [
                            "hotness",
                            "created",
                            "score"
                        ],
                        "type": "string",
                        "description": "Sort results by trending, newest, or popularity.",
                        "default": "hotness"
                    },
                    "maxPrompts": {
                        "title": "Max prompts",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of prompt listings to scrape.",
                        "default": 50
                    },
                    "includeDetails": {
                        "title": "Include detail pages",
                        "type": "boolean",
                        "description": "Visit each prompt's detail page for full description, reviews, and seller info. Slower but more data.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Select proxies for the actor. Datacenter proxies usually work fine."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
