# Alpine Linux Packages Scraper (`parseforge/alpine-linux-packages-scraper`) Actor

Pull the Alpine Linux package index by name, branch, repository, and architecture from pkgs.alpinelinux.org. Each record carries version, license, maintainer, project link, build date, commit hash, and full dependency lists. Handy for SBOM tracking, security audits, and mirror tooling.

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

## Pricing

from $19.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

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

## 🏔️ Alpine Linux Packages Scraper

> 🚀 **Turn the Alpine Linux package index into clean, structured records.** Query pkgs.alpinelinux.org by name, branch, repository, and architecture and get version, license, maintainer, and dependency data per package.

> 🕒 **Last updated:** 2026-07-14 · **📊 Up to 21 fields** per record · 10 branches · 9 architectures · main, community, and testing repos

Pull the official Alpine Linux package database straight from pkgs.alpinelinux.org and drop it into a spreadsheet, a database, or your own tooling. Filter with a glob on the package name, pick a release branch, narrow to a repository and architecture, and get one clean record per package with the metadata that matters: version, license, maintainer, project link, and build date.

Coverage is the live Alpine package index as the site publishes it: the rolling `edge` branch plus the stable `v3.x` releases, across `main`, `community`, and `testing` repositories and every supported CPU architecture. Turn on dependency enrichment and each package also carries its description, install size, origin, commit hash, build time, and full depends, provides, and sub package lists.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Security and DevSecOps teams | Audit versions and licenses, track CVEs |
| Platform and container engineers | Pin base image packages, build SBOMs |
| Distro maintainers and packagers | Watch versions across branches |
| Mirror and tooling operators | Snapshot the index for offline use |

### 📋 What the Alpine Linux Packages Scraper does

This Actor reads the public Alpine Linux package index at pkgs.alpinelinux.org and returns one clean record per package:

- **Listing fields** (always) — name, version, branch, repository, architecture, description, license, project URL, maintainer, build date, and the package page URL.
- **Dependency enrichment** (optional) — turn on `includeDependencies` and each package is enriched from its detail page with install size, origin, commit hash, commit URL, build time, and full `depends`, `provides`, and `subPackages` lists.

You control the package name glob, the branch, the repository, the architecture, and how many records come back. Every record carries a `scrapedAt` timestamp.

### 🎬 Full Demo (_🚧 Coming soon_)

### ⚙️ Input

| Field | Type | Description |
|---|---|---|
| `name` | string | Glob filter for the package name. Use `*` and `?` as wildcards, for example `apk*`, `python3*`, or `*ssl*`. Use `*` alone to match every package. |
| `branch` | select | Alpine release branch. `edge` (rolling) or a stable `v3.x` release. |
| `repo` | select | Repository to query. All, `main`, `community`, or `testing`. |
| `arch` | select | CPU architecture. All, `x86_64`, `aarch64`, and seven more. |
| `includeDependencies` | boolean | Enrich each package from its detail page with commit, build time, and dependency lists. Slower. |
| `maxItems` | integer | How many records to return. Free plan is capped at 10. |

**Example 1 — apk packages on edge with full dependency data**
```json
{
    "name": "apk*",
    "branch": "edge",
    "repo": "main",
    "arch": "x86_64",
    "includeDependencies": true,
    "maxItems": 50
}
````

**Example 2 — every Python package on a stable branch, listing only**

```json
{
    "name": "python3*",
    "branch": "v3.21",
    "repo": "",
    "arch": "x86_64",
    "includeDependencies": false,
    "maxItems": 200
}
```

> ⚠️ **Good to Know:** the `edge` branch is the rolling development tree and changes often, while `v3.x` branches are stable. Turning on `includeDependencies` visits one extra page per package, so large runs take noticeably longer. Leave it off when you only need version, license, and maintainer data.

### 📊 Output

Each enriched record looks like this:

| Field | Description |
|---|---|
| 📦 `name` | Package name |
| 🏷 `version` | Package version and release |
| 🌿 `branch` | Alpine branch (edge or v3.x) |
| 🗂 `repo` | Repository (main, community, testing) |
| 🖥 `arch` | CPU architecture |
| 📝 `description` | Short package description |
| ⚖️ `license` | SPDX license identifier |
| 🌐 `projectUrl` | Upstream project link |
| 👤 `maintainer` | Package maintainer |
| 📅 `buildDate` | Build date from the index |
| 🔗 `url` | Alpine package page URL |
| 📦 `size` | Download size |
| 💾 `installedSize` | Installed size |
| 🌱 `origin` | Origin (source) package |
| 🔑 `commit` | aports commit hash |
| 🔗 `commitUrl` | Link to the commit |
| 🛠 `buildTime` | Exact build timestamp |
| 🔢 `depends` | List of runtime dependencies |
| 🎁 `provides` | List of provided names |
| 🧩 `subPackages` | List of related sub packages |
| 🕒 `scrapedAt` | Collection timestamp |
| ❌ `error` | Null on success |

> The `size`, `installedSize`, `origin`, `commit`, `commitUrl`, `buildTime`, `depends`, `provides`, and `subPackages` fields are only present when `includeDependencies` is enabled.

**Real sample — enriched package**

```json
{
    "name": "apkbuild-cpan",
    "version": "3.17.0-r0",
    "branch": "edge",
    "repo": "main",
    "arch": "x86_64",
    "description": "Script to generate perl APKBUILD from CPAN",
    "license": "GPL-2.0-only",
    "projectUrl": "https://gitlab.alpinelinux.org/alpine/abuild/",
    "maintainer": "Natanael Copa",
    "buildDate": "2026-06-05 11:57:06",
    "url": "https://pkgs.alpinelinux.org/package/edge/main/x86_64/apkbuild-cpan",
    "size": "8.0KiB",
    "installedSize": "24.3KiB",
    "origin": "abuild",
    "commit": "c34e25a150fccc32194346cb335ed746d6878031",
    "commitUrl": "https://gitlab.alpinelinux.org/alpine/aports/-/commit/c34e25a150fccc32194346cb335ed746d6878031",
    "buildTime": "2026-06-05 11:57:06",
    "depends": ["perl", "perl-libwww", "perl-json", "perl-module-build", "perl-module-build-tiny", "perl-lwp-protocol-https"],
    "provides": ["cmd:apkbuild-cpan"],
    "subPackages": ["abuild-doc", "abuild-rootbld", "abuild-sudo", "apkbuild-cpan", "apkbuild-gem-resolver", "apkbuild-pypi"],
    "scrapedAt": "2026-06-08T18:03:11.403Z",
    "error": null
}
```

**Real sample — apk-tools**

```json
{
    "name": "apk-tools",
    "version": "3.0.6-r0",
    "branch": "edge",
    "repo": "main",
    "arch": "x86_64",
    "description": "Alpine Package Keeper - package manager for alpine",
    "license": "GPL-2.0-only",
    "projectUrl": "https://gitlab.alpinelinux.org/alpine/apk-tools",
    "maintainer": "Natanael Copa",
    "buildDate": "2026-04-13 09:23:00",
    "url": "https://pkgs.alpinelinux.org/package/edge/main/x86_64/apk-tools",
    "size": "53.4KiB",
    "installedSize": "112.4KiB",
    "origin": "apk-tools",
    "commit": "1403ea7a8ae3fb8e5a11207ddb1ff536eb8de912",
    "commitUrl": "https://gitlab.alpinelinux.org/alpine/aports/-/commit/1403ea7a8ae3fb8e5a11207ddb1ff536eb8de912",
    "buildTime": "2026-04-13 09:23:00",
    "depends": ["musl", "libcrypto3", "libapk", "ca-certificates-bundle", "so:libapk.so.3.0.0", "so:libc.musl-x86_64.so.1", "so:libz.so.1"],
    "provides": ["apk-tools3", "cmd:apk"],
    "subPackages": ["apk-tools-bash-completion", "apk-tools-dbg", "apk-tools-dev", "apk-tools-doc", "apk-tools-static", "apk-tools-zsh-completion", "libapk", "lua5.5-apk", "py3-apk"],
    "scrapedAt": "2026-06-08T18:03:14.000Z",
    "error": null
}
```

**Real sample — listing only**

```json
{
    "name": "python3",
    "version": "3.14.3-r0",
    "branch": "edge",
    "repo": "main",
    "arch": "x86_64",
    "description": "High-level scripting language",
    "license": "PSF-2.0",
    "projectUrl": "https://www.python.org/",
    "maintainer": "Natanael Copa",
    "buildDate": "2026-03-27 19:39:08",
    "url": "https://pkgs.alpinelinux.org/package/edge/main/x86_64/python3",
    "scrapedAt": "2026-06-08T18:01:33.970Z",
    "error": null
}
```

### ✨ Why choose this Actor

- One clean record per package, with stable field names that map onto a database schema.
- Filter exactly the slice you need by name glob, branch, repository, and architecture.
- Optional dependency enrichment expands depends, provides, and sub packages into ready arrays.
- No account, no key, and no login required.
- Pulls live from the official Alpine index, so versions reflect the catalog at run time.

### 📈 How it compares to alternatives

| Approach | Effort | Structured fields | Dependencies | Maintenance |
|---|---|---|---|---|
| This Actor | One run | Yes | Optional, expanded | None on your side |
| Parsing APKINDEX by hand | Hours | Manual | Manual | Constant |
| Scraping the site yourself | Days | Depends | You build it | You own the upkeep |

### 🚀 How to use

1. Create a free Apify account using [this sign-up link](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the Alpine Linux Packages Scraper.
3. Set the `name` glob, then pick a `branch`, `repo`, and `arch`.
4. Toggle `includeDependencies` if you want commit and dependency data, and set `maxItems`.
5. Click **Start** and grab your results when the run finishes.

### 💼 Business use cases

#### Security and compliance

| Goal | How this helps |
|---|---|
| Audit licenses across a branch | Pull `license` for every matching package |
| Track vulnerable versions | Snapshot `version` and `commit` over time |

#### Platform and containers

| Goal | How this helps |
|---|---|
| Pin base image packages | Capture exact versions per architecture |
| Build a software bill of materials | Use the expanded `depends` and `provides` lists |

#### Packaging and maintenance

| Goal | How this helps |
|---|---|
| Watch a package across branches | Re-run per branch and compare versions |
| Find who owns a package | Read the `maintainer` and `origin` fields |

#### Mirrors and tooling

| Goal | How this helps |
|---|---|
| Snapshot the index | Export the full listing for offline use |
| Feed an internal catalog | Load records into your own search tool |

### 🔌 Automating Alpine Linux Packages Scraper

Connect runs to the tools you already use:

- **Make** and **Zapier** to trigger runs and route records into sheets or databases.
- **Slack** to post a summary when a run finishes.
- **Airbyte** to load results into a warehouse.
- **GitHub** Actions to schedule periodic snapshots.
- **Google Drive** to archive each run's output.

### 🌟 Beyond business use cases

- **Research:** study how a distribution's package set evolves across releases.
- **Personal:** keep a watchlist of the packages you depend on.
- **Non-profit:** power a community mirror or documentation project.
- **Experimentation:** prototype a package search app without writing a scraper.

### 🤖 Ask an AI assistant

Paste your results into [ChatGPT](https://chat.openai.com), [Claude](https://claude.ai), [Perplexity](https://www.perplexity.ai), or [Microsoft Copilot](https://copilot.microsoft.com) and ask it to diff versions between branches, group packages by license, or map a dependency tree.

### ❓ Frequently Asked Questions

**Do I need an Alpine Linux account or an API key?**
No. The Actor reads the public package index at pkgs.alpinelinux.org, which needs no login or key.

**Which branches can I query?**
The rolling `edge` branch and the stable releases `v3.23` down to `v3.15`.

**Which repositories and architectures are supported?**
`main`, `community`, and `testing` repositories, and architectures including `x86_64`, `aarch64`, `armhf`, `armv7`, `ppc64le`, `riscv64`, `s390x`, `x86`, and `loongarch64`.

**How does the name filter work?**
It is a glob. Use `*` and `?` as wildcards, for example `apk*` matches everything starting with apk, and `*ssl*` matches anything containing ssl.

**What is the difference with and without dependency enrichment?**
Without it you get the listing table fields. With `includeDependencies` on, each package also returns install size, origin, commit, build time, and the full depends, provides, and sub package lists, at the cost of one extra page visit per package.

**Why are some detail fields missing on a record?**
The extra fields only appear when `includeDependencies` is enabled. With it off, records carry the listing fields only.

**How current is the data?**
Each run pulls live from the Alpine index, so versions and build dates reflect the catalog at run time.

**Can I get every package?**
Yes. Use `*` as the name with a high `maxItems`. The Actor pages through the full result set for your filters.

**What does the origin field mean?**
It is the source package a binary package is built from. Several binary packages can share one origin.

**Can I schedule this?**
Yes. Use Apify Schedules to snapshot the index on any cadence you like.

### 🔌 Integrate with any app

Results are available through the Apify API, so you can pull them into any app, database, or workflow you already run.

### 🔗 Recommended Actors

- [Have I Been Pwned Breaches Catalog Scraper](https://apify.com/parseforge)
- More developer and reference data Actors in the [ParseForge collection](https://apify.com/parseforge)

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge).

**🆘 Need Help?** [Open our contact form](https://tally.so/r/BzdKgA)

> **⚠️ Disclaimer:** independent tool, not affiliated with Alpine Linux. Only publicly available data is collected.

# Actor input Schema

## `name` (type: `string`):

Glob filter for the package name. Use \* and ? as wildcards, for example 'apk\*', 'python3\*', or '*ssl*'. Use '\*' alone to match every package.

## `branch` (type: `string`):

Alpine release branch to query. 'edge' is the rolling development branch; the v3.x branches are stable releases.

## `repo` (type: `string`):

Repository to query. 'All' searches every repository. 'main' is the core supported set, 'community' is community-maintained, 'testing' is edge-only staging.

## `arch` (type: `string`):

CPU architecture to query. 'All' searches every architecture.

## `includeDependencies` (type: `boolean`):

When enabled, each package is enriched from its detail page with description, install size, origin, commit hash, build time, and full depends and provides lists. This visits one extra page per package, so runs are slower.

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

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

## Actor input object example

```json
{
  "name": "apk*",
  "branch": "edge",
  "repo": "",
  "arch": "x86_64",
  "includeDependencies": false,
  "maxItems": 10
}
```

# Actor output Schema

## `results` (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 = {
    "name": "apk*",
    "maxItems": 10
};

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Alpine Linux Packages Scraper",
        "description": "Pull the Alpine Linux package index by name, branch, repository, and architecture from pkgs.alpinelinux.org. Each record carries version, license, maintainer, project link, build date, commit hash, and full dependency lists. Handy for SBOM tracking, security audits, and mirror tooling.",
        "version": "0.1",
        "x-build-id": "k92aWHo1xWY14Bjy8"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~alpine-linux-packages-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-alpine-linux-packages-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/parseforge~alpine-linux-packages-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-alpine-linux-packages-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/parseforge~alpine-linux-packages-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-alpine-linux-packages-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": {
                    "name": {
                        "title": "Package name filter",
                        "type": "string",
                        "description": "Glob filter for the package name. Use * and ? as wildcards, for example 'apk*', 'python3*', or '*ssl*'. Use '*' alone to match every package."
                    },
                    "branch": {
                        "title": "Branch",
                        "enum": [
                            "edge",
                            "v3.23",
                            "v3.22",
                            "v3.21",
                            "v3.20",
                            "v3.19",
                            "v3.18",
                            "v3.17",
                            "v3.16",
                            "v3.15"
                        ],
                        "type": "string",
                        "description": "Alpine release branch to query. 'edge' is the rolling development branch; the v3.x branches are stable releases.",
                        "default": "edge"
                    },
                    "repo": {
                        "title": "Repository",
                        "enum": [
                            "",
                            "main",
                            "community",
                            "testing"
                        ],
                        "type": "string",
                        "description": "Repository to query. 'All' searches every repository. 'main' is the core supported set, 'community' is community-maintained, 'testing' is edge-only staging.",
                        "default": ""
                    },
                    "arch": {
                        "title": "Architecture",
                        "enum": [
                            "",
                            "x86_64",
                            "x86",
                            "aarch64",
                            "armhf",
                            "armv7",
                            "ppc64le",
                            "riscv64",
                            "s390x",
                            "loongarch64"
                        ],
                        "type": "string",
                        "description": "CPU architecture to query. 'All' searches every architecture.",
                        "default": "x86_64"
                    },
                    "includeDependencies": {
                        "title": "Include dependencies and commit details",
                        "type": "boolean",
                        "description": "When enabled, each package is enriched from its detail page with description, install size, origin, commit hash, build time, and full depends and provides lists. This visits one extra page per package, so runs are slower.",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
