# Pornhub Scraper (`solidcode/pornhub-scraper`) Actor

\[💰 $4.00 / 1K] Extract public Pornhub video data — title, duration, views, rating, votes, tags, categories, pornstars, channel, thumbnail, and upload date. Scrape by keyword search or paste video, search, channel, model, pornstar, and category URLs. Optional direct media/download links.

- **URL**: https://apify.com/solidcode/pornhub-scraper.md
- **Developed by:** [SolidCode](https://apify.com/solidcode) (community)
- **Categories:** Videos, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 results

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## Pornhub Scraper

Pull public video data from Pornhub at scale — titles, durations, view counts, up-votes, upload dates, categories, tags, pornstar lists, channel details, thumbnails, and optional HD stream links — from search keywords or any video, channel, model, pornstar, or category page. Built for media researchers, content analysts, and data teams who need structured adult-video metadata in bulk without collecting it page by page.

### Why This Scraper?

- **6 input URL types in one actor** — individual video, search results, channel, model, pornstar, and category pages all flow into a single clean dataset, no per-type setup.
- **Keyword search built in** — type a performer name or topic and the actor runs the search for you; no need to hand-craft a search URL.
- **5 sort orders** — Most Relevant, Most Recent, Most Viewed, Top Rated, and Longest, applied across every search and listing page.
- **20+ structured fields per video** — including arrays for categories, tags, and pornstar lists, plus production type, channel name and URL, view count, and up-votes.
- **Related-video expansion, capped per source** — optionally pull the suggested videos from each video page as extra flat rows, with a per-video cap so your result count stays predictable.
- **HD stream links at 4 qualities** — opt in for direct media links: 1080p, 720p, 480p, and 240p streams plus MP4 links for download workflows.
- **One flat row per video** — every result is a single record (no nested child arrays), so search results, channel catalogs, and related videos all land in the same table ready to filter and export.
- **ISO-8601 dates and clean arrays** — upload dates are normalized and empty placeholder values are stripped, so you never get junk sentinels like `"No"` in your pornstar or category fields.

### Use Cases

**Market & Trend Research**
- Track which categories and tags trend across Most Viewed and Top Rated listings
- Compare view counts and up-votes across a topic to gauge audience demand
- Surface the longest or most-recent uploads for a search term
- Build view-count time series by re-running a saved search on a schedule

**Content Cataloging**
- Pull a channel, model, or pornstar's full back catalog into a single sheet
- Index videos by category and tag for a searchable internal library
- Capture thumbnails and embed URLs for content management systems
- Map production type (professional vs. homemade) across a creator's output

**Competitive & Creator Analysis**
- Benchmark a creator's upload cadence and engagement against peers
- Compare category mix and tagging strategies between channels
- Monitor a pornstar page for new releases and rising view counts
- Analyze which tags correlate with the highest view counts in a niche

**Dataset Building**
- Assemble a labeled video-metadata dataset for media or recommendation research
- Collect related-video graphs to study suggestion patterns
- Export view, vote, and duration distributions for statistical analysis
- Feed structured rows into dashboards and BI tools

**Compliance & Moderation Research**
- Compile public metadata for content-policy and moderation studies
- Track category and tag prevalence for safety research
- Build reference sets of public listings for academic or legal review

### Getting Started

#### Keyword Search

The simplest run — one keyword, default of 100 videos:

```json
{
    "searchQueries": ["massage"]
}
````

#### Sorted Multi-URL Run

Collect from several pages and order them by most viewed:

```json
{
    "startUrls": [
        "https://www.pornhub.com/model/example-model/videos",
        "https://www.pornhub.com/categories/example-category"
    ],
    "sortBy": "mv",
    "maxResults": 200
}
```

#### Full Configuration

Search and listing pages with related videos and direct media links enabled:

```json
{
    "searchQueries": ["amateur"],
    "startUrls": [
        "https://www.pornhub.com/view_video.php?viewkey=ph0000000000000"
    ],
    "sortBy": "tr",
    "maxResults": 500,
    "includeRelatedVideos": true,
    "maxRelatedPerVideo": 10,
    "includeDownloadUrls": true
}
```

### Input Reference

#### What to Scrape

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `startUrls` | string\[] | `[]` | Pornhub URLs to collect. Works with video, search results, channel, model, pornstar, user, and category pages. The actor auto-detects each URL type. |
| `searchQueries` | string\[] | `[]` | Keywords to search on Pornhub (for example a performer name or a topic). Each query runs its own search and the matching videos are collected. |

#### Options

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `maxResults` | integer | `100` | The most videos to collect in total across all URLs and searches. Set to `0` for no limit (up to a safety ceiling of 100,000). |
| `sortBy` | select | `Most Relevant` | Order for search and listing pages: Most Relevant, Most Recent, Most Viewed, Top Rated, or Longest. |
| `includeRelatedVideos` | boolean | `false` | Also collect the related videos suggested on each video page, added as extra rows. Use the cap below to control how many. |
| `maxRelatedPerVideo` | integer | `10` | When related videos is on, the most related videos to keep for each source video. Keeps your result count predictable. |
| `includeDownloadUrls` | boolean | `false` | Include direct media links (streaming and download URLs) for each video. Useful for download workflows. |

### Output

Every result is one flat row with `recordType: "video"`. Here's a representative result with download links enabled:

```json
{
    "recordType": "video",
    "videoId": "1234567890",
    "viewKey": "ph0000000000000",
    "url": "https://www.pornhub.com/view_video.php?viewkey=ph0000000000000",
    "embedUrl": "https://www.pornhub.com/embed/ph0000000000000",
    "title": "Relaxing Full Body Massage Session",
    "duration": 676,
    "durationFormatted": "11:16",
    "views": 480121,
    "upVotes": 3120,
    "uploadDate": "2026-05-26",
    "categories": ["Massage", "Amateur"],
    "tags": ["relaxing", "oil", "full body"],
    "pornstars": ["Jane Example"],
    "productionType": "homemade",
    "channelName": "Example Studio",
    "channelUrl": "https://www.pornhub.com/channels/example-studio",
    "thumbnailUrl": "https://di.phncdn.com/videos/example/thumb.jpg",
    "previewUrl": "https://dl.phncdn.com/videos/example/preview.webm",
    "masterM3u8Url": "https://ev.phncdn.com/hls/videos/example/master.m3u8",
    "bestM3u8Url": "https://ev.phncdn.com/hls/videos/example/index-v1-a1.m3u8",
    "downloadUrls": [
        { "quality": "1080", "format": "hls", "videoUrl": "https://ev.phncdn.com/hls/videos/example/index-1080.m3u8" },
        { "quality": "720", "format": "hls", "videoUrl": "https://ev.phncdn.com/hls/videos/example/index-720.m3u8" }
    ],
    "sourceUrl": "https://www.pornhub.com/video/search?search=massage",
    "scrapedAt": "2026-06-10T14:30:00+00:00"
}
```

#### Core Fields

| Field | Type | Description |
|-------|------|-------------|
| `recordType` | string | Always `"video"` |
| `videoId` | string | Numeric video identifier |
| `viewKey` | string | Pornhub viewkey token for the video |
| `url` | string | Canonical video URL |
| `embedUrl` | string | Embeddable player URL |
| `title` | string | Video title |
| `sourceUrl` | string | The input URL or search query that produced this row |
| `scrapedAt` | string | ISO-8601 timestamp of when the row was collected |

#### Engagement & Timing

| Field | Type | Description |
|-------|------|-------------|
| `duration` | integer | Length in seconds |
| `durationFormatted` | string | Length as `H:MM:SS` or `M:SS` |
| `views` | integer | View count |
| `upVotes` | integer | Number of up-votes |
| `uploadDate` | string | ISO-8601 upload/publish date |

#### Taxonomy & Channel

| Field | Type | Description |
|-------|------|-------------|
| `categories` | string\[] | Category labels |
| `tags` | string\[] | Tag labels |
| `pornstars` | string\[] | Listed performers |
| `productionType` | string | `professional` or `homemade` when known |
| `channelName` | string | Uploader / channel name |
| `channelUrl` | string | Uploader / channel URL |
| `thumbnailUrl` | string | Primary thumbnail URL |
| `previewUrl` | string | Animated hover-preview clip URL (when available) |

#### Media Links

Populated only when `includeDownloadUrls` is on.

| Field | Type | Description |
|-------|------|-------------|
| `masterM3u8Url` | string | Master playlist URL covering all available stream qualities |
| `bestM3u8Url` | string | Highest-quality stream URL |
| `downloadUrls` | object\[] | Stream and download links as `{ quality, format, videoUrl }` |

Empty fields are stripped from each row, so a video with no listed performers simply omits `pornstars` rather than returning an empty value.

### Tips for Best Results

- **Start small to test.** Set `maxResults` to 10–20 on your first run to confirm the data matches your needs, then scale up.
- **Use a model or pornstar URL to pull a full catalog.** A creator's `/videos` page returns their entire back catalog, bounded only by `maxResults` — the fastest way to snapshot everything one creator has published.
- **Pick the sort that matches your goal.** Use Most Viewed or Top Rated for trend research, Most Recent to monitor new uploads, and Longest to surface full-length content.
- **Fetch media links promptly.** When `includeDownloadUrls` is on, the stream and download URLs are time-limited and tied to the network that requested them — use them right after the run rather than saving them for later.
- **Keep related videos capped.** Turning on `includeRelatedVideos` adds extra rows per source video; leave `maxRelatedPerVideo` modest (5–10) so your total result count stays predictable.
- **Mix URLs and keywords in one run.** Combine `startUrls` and `searchQueries` in a single invocation — they share the global `maxResults` budget and land in the same dataset.
- **Set `maxResults` to 0 for everything.** When you want a creator's or category's complete listing, use `0` (capped at a 100,000 safety ceiling) instead of guessing a number.
- **Plan very large pulls in batches.** Results are collected page by page, so a single run gathers as many videos as fit within its time limit. For very large catalogs, raise the run's time limit in the run options, or split the work across several runs (for example by sorting or by separate searches) and merge the datasets afterward.

### Pricing

**From $4.00 per 1,000 results** — a flat per-result rate that undercuts comparable Pornhub data tools. Bronze, Silver, and Gold subscribers pay progressively less; the table below shows the total cost at each discount tier.

| Results | No discount | Bronze | Silver | Gold |
|---------|-------------|--------|--------|------|
| 100 | $0.48 | $0.45 | $0.43 | $0.40 |
| 1,000 | $4.80 | $4.50 | $4.30 | $4.00 |
| 10,000 | $48.00 | $45.00 | $43.00 | $40.00 |
| 100,000 | $480.00 | $450.00 | $430.00 | $400.00 |

A "result" is any video row in the output dataset, including related videos when that option is on. No compute or time-based charges — you pay per result, plus a small fixed per-run start fee.

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Zapier** / **Make** / **n8n** — Workflow automation
- **Google Sheets** — Direct spreadsheet export
- **Slack** / **Email** — Notifications on new results
- **Webhooks** — Trigger custom APIs on run completion
- **Apify API** — Full programmatic access

### Legal & Ethical Use

This actor collects only publicly available video metadata and is intended for legitimate research, content cataloging, and analytics. It is for adults aged 18 or older. Users are responsible for complying with applicable laws, local regulations, and Pornhub's Terms of Service, and for using collected data only for their own lawful, compliant purposes. Do not use extracted data for spam, harassment, or any illegal purpose, and respect the rights and privacy of the people depicted.

# Actor input Schema

## `startUrls` (type: `array`):

Pornhub URLs to scrape. Works with video pages, search results, channels, models, pornstars, users, and category pages. Paste one or more to get started.

## `searchQueries` (type: `array`):

Keywords to search on Pornhub (for example a performer name or a topic). Each query runs its own search and the matching videos are collected.

## `maxResults` (type: `integer`):

The most videos to collect in total across all URLs and searches. Set to 0 for no limit. Very large pulls are collected page by page over time, so a single run returns as many as fit within the run's time limit — for very large catalogs, raise the run's time limit or split the work across several runs.

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

How to order results from search and listing pages.

## `includeRelatedVideos` (type: `boolean`):

Also collect the related videos suggested on each video page. This adds extra results — use the cap below to control how many.

## `maxRelatedPerVideo` (type: `integer`):

When 'Include Related Videos' is on, the most related videos to keep for each source video. Keeps your result count predictable.

## `includeDownloadUrls` (type: `boolean`):

Include direct media links (streaming and download URLs) for each video. Useful for download workflows.

## Actor input object example

```json
{
  "startUrls": [],
  "searchQueries": [],
  "maxResults": 100,
  "sortBy": "relevance",
  "includeRelatedVideos": false,
  "maxRelatedPerVideo": 10,
  "includeDownloadUrls": false
}
```

# Actor output Schema

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

Table of collected videos with key fields.

# 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 = {
    "startUrls": [],
    "searchQueries": [],
    "maxResults": 100,
    "sortBy": "relevance",
    "includeRelatedVideos": false,
    "maxRelatedPerVideo": 10,
    "includeDownloadUrls": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/pornhub-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 = {
    "startUrls": [],
    "searchQueries": [],
    "maxResults": 100,
    "sortBy": "relevance",
    "includeRelatedVideos": False,
    "maxRelatedPerVideo": 10,
    "includeDownloadUrls": False,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/pornhub-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 '{
  "startUrls": [],
  "searchQueries": [],
  "maxResults": 100,
  "sortBy": "relevance",
  "includeRelatedVideos": false,
  "maxRelatedPerVideo": 10,
  "includeDownloadUrls": false
}' |
apify call solidcode/pornhub-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Pornhub Scraper",
        "description": "[💰 $4.00 / 1K] Extract public Pornhub video data — title, duration, views, rating, votes, tags, categories, pornstars, channel, thumbnail, and upload date. Scrape by keyword search or paste video, search, channel, model, pornstar, and category URLs. Optional direct media/download links.",
        "version": "1.0",
        "x-build-id": "NfGqi4Myn5tlgiK0r"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~pornhub-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-pornhub-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/solidcode~pornhub-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-pornhub-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/solidcode~pornhub-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-pornhub-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": {
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Pornhub URLs to scrape. Works with video pages, search results, channels, models, pornstars, users, and category pages. Paste one or more to get started.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchQueries": {
                        "title": "Search Queries",
                        "type": "array",
                        "description": "Keywords to search on Pornhub (for example a performer name or a topic). Each query runs its own search and the matching videos are collected.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "Maximum Results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "The most videos to collect in total across all URLs and searches. Set to 0 for no limit. Very large pulls are collected page by page over time, so a single run returns as many as fit within the run's time limit — for very large catalogs, raise the run's time limit or split the work across several runs.",
                        "default": 100
                    },
                    "sortBy": {
                        "title": "Sort Order",
                        "enum": [
                            "relevance",
                            "mr",
                            "mv",
                            "tr",
                            "lg"
                        ],
                        "type": "string",
                        "description": "How to order results from search and listing pages.",
                        "default": "relevance"
                    },
                    "includeRelatedVideos": {
                        "title": "Include Related Videos",
                        "type": "boolean",
                        "description": "Also collect the related videos suggested on each video page. This adds extra results — use the cap below to control how many.",
                        "default": false
                    },
                    "maxRelatedPerVideo": {
                        "title": "Max Related Videos per Video",
                        "minimum": 0,
                        "type": "integer",
                        "description": "When 'Include Related Videos' is on, the most related videos to keep for each source video. Keeps your result count predictable.",
                        "default": 10
                    },
                    "includeDownloadUrls": {
                        "title": "Include Download Links",
                        "type": "boolean",
                        "description": "Include direct media links (streaming and download URLs) for each video. Useful for download workflows.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
